Coverage Report

Files:	75
Lines:	13993
Covered:	3093 / 4153 (74.5%)

Lines covered:	67 / 116 (57.8%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./Interfaces/IActivePool.sol";
import "./Interfaces/ICollSurplusPool.sol";
import "./Dependencies/ICollateralToken.sol";
import "./Interfaces/ICdpManagerData.sol";
import "./Dependencies/ERC3156FlashLender.sol";
import "./Dependencies/SafeERC20.sol";
import "./Dependencies/ReentrancyGuard.sol";
import "./Dependencies/AuthNoOwner.sol";
import "./Dependencies/BaseMath.sol";

/**
 * The Active Pool holds the collateral and EBTC debt (but not EBTC tokens) for all active cdps.
 *
 * When a cdp is liquidated, it's collateral and EBTC debt are transferred from the Active Pool, to either the
 * Stability Pool, the Default Pool, or both, depending on the liquidation conditions.
 */
contract ActivePool is IActivePool, ERC3156FlashLender, ReentrancyGuard, BaseMath, AuthNoOwner {
    using SafeERC20 for IERC20;
    string public constant NAME = "ActivePool";

    address public immutable borrowerOperationsAddress;
    address public immutable cdpManagerAddress;
    address public immutable collSurplusPoolAddress;
    address public feeRecipientAddress;

    uint256 internal systemCollShares; // deposited collateral tracker
    uint256 internal systemDebt;
    uint256 internal feeRecipientCollShares; // coll shares claimable by fee recipient
    ICollateralToken public collateral;

    // --- Contract setters ---

    /// @notice Constructor for the ActivePool contract
    /// @dev Initializes the contract with the borrowerOperationsAddress, cdpManagerAddress, collateral token address, collSurplusAddress, and feeRecipientAddress
    /// @param _borrowerOperationsAddress The address of the Borrower Operations contract
    /// @param _cdpManagerAddress The address of the Cdp Manager contract
    /// @param _collTokenAddress The address of the collateral token
    /// @param _collSurplusAddress The address of the collateral surplus pool
    /// @param _feeRecipientAddress The address of the fee recipient

    constructor(
        address _borrowerOperationsAddress,
        address _cdpManagerAddress,
        address _collTokenAddress,
        address _collSurplusAddress,
        address _feeRecipientAddress
    ) {
        borrowerOperationsAddress = _borrowerOperationsAddress;
        cdpManagerAddress = _cdpManagerAddress;
        collateral = ICollateralToken(_collTokenAddress);
        collSurplusPoolAddress = _collSurplusAddress;
        feeRecipientAddress = _feeRecipientAddress;

        // TEMP: read authority to avoid signature change
        address _authorityAddress = address(AuthNoOwner(cdpManagerAddress).authority());
        if (_authorityAddress != address(0)) {
            _initializeAuthority(_authorityAddress);
        }

        emit FeeRecipientAddressChanged(_feeRecipientAddress);
    }

    // --- Getters for public variables. Required by IPool interface ---

    /// @notice Amount of stETH collateral shares in the contract
    /// @dev Not necessarily equal to the the contract's raw systemCollShares balance - tokens can be forcibly sent to contracts
    /// @return uint256 The amount of systemCollShares allocated to the pool

    function getSystemCollShares() external view override returns (uint256) {
        return systemCollShares;
    }

    /// @notice Returns the systemDebt state variable
    /// @dev The amount of EBTC debt in the pool. Like systemCollShares, this is not necessarily equal to the contract's EBTC token balance - tokens can be forcibly sent to contracts
    /// @return uint256 The amount of EBTC debt in the pool

    function getSystemDebt() external view override returns (uint256) {
        return systemDebt;
    }

    /// @notice The amount of stETH collateral shares claimable by the fee recipient
    /// @return uint256 The amount of collateral shares claimable by the fee recipient

    function getFeeRecipientClaimableCollShares() external view override returns (uint256) {
        return feeRecipientCollShares;
    }

    // --- Pool functionality ---

    /// @notice Sends stETH collateral shares to a specified account
    /// @dev Only for use by system contracts, the caller must be either BorrowerOperations or CdpManager
    /// @param _account The address of the account to send stETH to
    /// @param _shares The amount of stETH shares to send

    function transferSystemCollShares(address _account, uint256 _shares) public override {
        _requireCallerIsBOorCdpM();

        uint256 cachedSystemCollShares = systemCollShares;
        require(cachedSystemCollShares >= _shares, "!ActivePoolBal");
        unchecked {
            // Can use unchecked due to above
            cachedSystemCollShares -= _shares; // Updating here avoids an SLOAD
        }

        systemCollShares = cachedSystemCollShares;

        emit SystemCollSharesUpdated(cachedSystemCollShares);
        emit CollSharesTransferred(_account, _shares);

        _transferCollSharesWithContractHooks(_account, _shares);
    }

    /// @notice Sends stETH to a specified account, drawing from both core shares and liquidator rewards shares
    /// @notice Liquidator reward shares are not tracked via internal accounting in the active pool and are assumed to be present in expected amount as part of the intended behavior of BorowerOperations and CdpManager
    /// @dev Liquidator reward shares are added when a cdp is opened, and removed when it is closed
    /// @dev closeCdp() or liqudations result in the actor (borrower or liquidator respectively) receiving the liquidator reward shares
    /// @dev Redemptions result in the shares being sent to the coll surplus pool for claiming by the CDP owner
    /// @dev Note that funds in the coll surplus pool, just like liquidator reward shares, are not tracked as part of the system CR or coll of a CDP.
    /// @dev Requires that the caller is either BorrowerOperations or CdpManager
    /// @param _account The address of the account to send systemCollShares and the liquidator reward to
    /// @param _shares The amount of systemCollShares to send
    /// @param _liquidatorRewardShares The amount of the liquidator reward shares to send

    function transferSystemCollSharesAndLiquidatorReward(
        address _account,
        uint256 _shares,
        uint256 _liquidatorRewardShares
    ) external override {
        _requireCallerIsBOorCdpM();

        uint256 cachedSystemCollShares = systemCollShares;
        require(cachedSystemCollShares >= _shares, "ActivePool: Insufficient collateral shares");
        uint256 totalShares = _shares + _liquidatorRewardShares; // TODO: Is this safe?
        unchecked {
            // Safe per the check above
            cachedSystemCollShares -= _shares;
        }
        systemCollShares = cachedSystemCollShares;

        emit SystemCollSharesUpdated(cachedSystemCollShares);
        emit CollSharesTransferred(_account, totalShares);

        _transferCollSharesWithContractHooks(_account, totalShares);
    }

    /// @notice Allocate stETH shares from the system to the fee recipient to claim at-will (pull model)
    /// @dev Requires that the caller is CdpManager
    /// @dev Only the current fee recipient address is able to claim the shares
    /// @dev If the fee recipient address is changed while outstanding claimable coll is available, only the new fee recipient will be able to claim the outstanding coll
    /// @param _shares The amount of systemCollShares to allocate to the fee recipient

    function allocateSystemCollSharesToFeeRecipient(uint256 _shares) external override {
        _requireCallerIsCdpManager();

        uint256 cachedSystemCollShares = systemCollShares;

        require(cachedSystemCollShares >= _shares, "ActivePool: Insufficient collateral shares");
        unchecked {
            // Safe per the check above
            cachedSystemCollShares -= _shares;
        }

        systemCollShares = cachedSystemCollShares;

        uint256 cachedFeeRecipientCollShares = feeRecipientCollShares + _shares;
        feeRecipientCollShares = cachedFeeRecipientCollShares;

        emit SystemCollSharesUpdated(cachedSystemCollShares);
        emit FeeRecipientClaimableCollSharesIncreased(cachedFeeRecipientCollShares, _shares);
    }

    /// @notice Helper function to transfer stETH shares to another address, ensuring to call hooks into other system pools if they are the recipient
    /// @param _account The address to transfer shares to
    /// @param _shares The amount of shares to transfer

    function _transferCollSharesWithContractHooks(address _account, uint256 _shares) internal {
        // NOTE: No need for safe transfer if the collateral asset is standard. Make sure this is the case!
        collateral.transferShares(_account, _shares);

        if (_account == collSurplusPoolAddress) {
            ICollSurplusPool(_account).increaseTotalSurplusCollShares(_shares);
        }
    }

    /// @notice Increases the tracked EBTC debt of the system by a specified amount
    /// @dev Managed by system contracts - requires that the caller is either BorrowerOperations or CdpManager
    /// @param _amount: The amount to increase the system EBTC debt by

    function increaseSystemDebt(uint256 _amount) external override {
        _requireCallerIsBOorCdpM();

        uint256 cachedSystemDebt = systemDebt + _amount;

        systemDebt = cachedSystemDebt;
        emit ActivePoolEBTCDebtUpdated(cachedSystemDebt);
    }

    /// @notice Decreases the tracked EBTC debt of the system by a specified amount
    /// @dev Managed by system contracts - requires that the caller is either BorrowerOperations or CdpManager
    /// @param _amount: The amount to decrease the system EBTC debt by

    function decreaseSystemDebt(uint256 _amount) external override {
        _requireCallerIsBOorCdpM();

        uint256 cachedSystemDebt = systemDebt - _amount;

        systemDebt = cachedSystemDebt;
        emit ActivePoolEBTCDebtUpdated(cachedSystemDebt);
    }

    // --- 'require' functions ---

    /// @notice Checks if the caller is BorrowerOperations
    function _requireCallerIsBorrowerOperations() internal view {
        require(
            msg.sender == borrowerOperationsAddress,
            "ActivePool: Caller is not BorrowerOperations"
        );
    }

    /// @notice Checks if the caller is either BorrowerOperations or CdpManager
    function _requireCallerIsBOorCdpM() internal view {
        require(
            msg.sender == borrowerOperationsAddress || msg.sender == cdpManagerAddress,
            "ActivePool: Caller is neither BorrowerOperations nor CdpManager"
        );
    }

    /// @notice Checks if the caller is CdpManager
    function _requireCallerIsCdpManager() internal view {
        require(msg.sender == cdpManagerAddress, "ActivePool: Caller is not CdpManager");
    }

    /// @notice Notify that stETH collateral shares have been recieved, updating internal accounting accordingly
    /// @param _value The amount of collateral to receive

    function increaseSystemCollShares(uint256 _value) external override {
        _requireCallerIsBorrowerOperations();

        uint256 cachedSystemCollShares = systemCollShares + _value;
        systemCollShares = cachedSystemCollShares;
        emit SystemCollSharesUpdated(cachedSystemCollShares);
    }

    // === Flashloans === //

    /// @notice Borrow assets with a flash loan
    /// @dev The Collateral checks may cause reverts if you trigger a fee change big enough
    ///         consider calling `cdpManagerAddress.syncGlobalAccountingAndGracePeriod()`
    /// @param receiver The address to receive the flash loan
    /// @param token The address of the token to loan
    /// @param amount The amount of tokens to loan
    /// @param data Additional data
    /// @return A boolean value indicating whether the operation was successful

    function flashLoan(
        IERC3156FlashBorrower receiver,
        address token,
        uint256 amount,
        bytes calldata data
    ) external override returns (bool) {
        require(amount > 0, "ActivePool: 0 Amount");
        uint256 fee = flashFee(token, amount); // NOTE: Check for `token` is implicit in the requires above // also checks for paused
        require(amount <= maxFlashLoan(token), "ActivePool: Too much");

        uint256 amountWithFee = amount + fee;
        uint256 oldRate = collateral.getPooledEthByShares(DECIMAL_PRECISION);

        collateral.transfer(address(receiver), amount);

        // Callback
        require(
            receiver.onFlashLoan(msg.sender, token, amount, fee, data) == FLASH_SUCCESS_VALUE,
            "ActivePool: IERC3156: Callback failed"
        );

        // Transfer of (principal + Fee) from flashloan receiver
        collateral.transferFrom(address(receiver), address(this), amountWithFee);

        // Send earned fee to designated recipient
        collateral.transfer(feeRecipientAddress, fee);

        // Check new balance
        // NOTE: Invariant Check, technically breaks CEI but I think we must use it
        // NOTE: This means any balance > systemCollShares is stuck, this is also present in LUSD as is

        // NOTE: This check effectively prevents running 2 FL at the same time
        //  You technically could, but you'd be having to repay any amount below systemCollShares to get Fl2 to not revert
        require(
            collateral.balanceOf(address(this)) >= collateral.getPooledEthByShares(systemCollShares),
            "ActivePool: Must repay Balance"
        );
        require(
            collateral.sharesOf(address(this)) >= systemCollShares,
            "ActivePool: Must repay Share"
        );
        require(
            collateral.getPooledEthByShares(DECIMAL_PRECISION) == oldRate,
            "ActivePool: Should keep same collateral share rate"
        );

        emit FlashLoanSuccess(address(receiver), token, amount, fee);

        return true;
    }

    /// @notice Calculate the flash loan fee for a given token and amount loaned
    /// @param token The address of the token to calculate the fee for
    /// @param amount The amount of tokens to calculate the fee for
    /// @return The amount of the flash loan fee

    function flashFee(address token, uint256 amount) public view override returns (uint256) {
        require(token == address(collateral), "ActivePool: collateral Only");
        require(!flashLoansPaused, "ActivePool: Flash Loans Paused");

        return (amount * feeBps) / MAX_BPS;
    }

    /// @notice Get the maximum flash loan amount for a specific token
    /// @dev Exclusively used here for stETH collateral, equal to the current balance of the pool
    /// @param token The address of the token to get the maximum flash loan amount for
    /// @return The maximum flash loan amount for the token
    function maxFlashLoan(address token) public view override returns (uint256) {
        if (token != address(collateral)) {
            return 0;
        }

        if (flashLoansPaused) {
            return 0;
        }

        return collateral.balanceOf(address(this));
    }

    // === Governed Functions === //

    /// @notice Claim outstanding shares for fee recipient, updating internal accounting and transferring the shares.
    /// @dev Call permissinos are managed via authority for flexibility, rather than gating call to just feeRecipient.
    /// @dev Is likely safe as an open permission though caution should be taken.
    /// @param _shares The amount of shares to claim to feeRecipient
    function claimFeeRecipientCollShares(uint256 _shares) external override requiresAuth {
        ICdpManagerData(cdpManagerAddress).syncGlobalAccountingAndGracePeriod(); // Calling this increases shares so do it first

        uint256 cachedFeeRecipientCollShares = feeRecipientCollShares;
        require(
            cachedFeeRecipientCollShares >= _shares,
            "ActivePool: Insufficient fee recipient coll"
        );

        unchecked {
            cachedFeeRecipientCollShares -= _shares;
        }

        feeRecipientCollShares = cachedFeeRecipientCollShares;
        emit FeeRecipientClaimableCollSharesDecreased(cachedFeeRecipientCollShares, _shares);

        collateral.transferShares(feeRecipientAddress, _shares);
    }

    /// @dev Function to move unintended dust that are not protected
    /// @notice moves given amount of given token (collateral is NOT allowed)
    /// @notice because recipient are fixed, this function is safe to be called by anyone

    function sweepToken(address token, uint256 amount) public nonReentrant requiresAuth {
        ICdpManagerData(cdpManagerAddress).syncGlobalAccountingAndGracePeriod(); // Accrue State First

        require(token != address(collateral), "ActivePool: Cannot Sweep Collateral");

        uint256 balance = IERC20(token).balanceOf(address(this));
        require(amount <= balance, "ActivePool: Attempt to sweep more than balance");

        address cachedFeeRecipientAddress = feeRecipientAddress; // Saves an SLOAD

        IERC20(token).safeTransfer(cachedFeeRecipientAddress, amount);

        emit SweepTokenSuccess(token, amount, cachedFeeRecipientAddress);
    }

    /// @notice Set new FeeRecipient
    /// @dev Previous fees are forfeited, if you wish to claim to previous address
    ///       call `claimFeeRecipientCollShares` first
    function setFeeRecipientAddress(address _feeRecipientAddress) external requiresAuth {
        ICdpManagerData(cdpManagerAddress).syncGlobalAccountingAndGracePeriod(); // Accrue State First

        require(
            _feeRecipientAddress != address(0),
            "ActivePool: Cannot set fee recipient to zero address"
        );

        feeRecipientAddress = _feeRecipientAddress;
        emit FeeRecipientAddressChanged(_feeRecipientAddress);
    }

    /// @notice Sets new Fee for FlashLoans
    function setFeeBps(uint256 _newFee) external requiresAuth {
        ICdpManagerData(cdpManagerAddress).syncGlobalAccountingAndGracePeriod(); // Accrue State First

        require(_newFee <= MAX_FEE_BPS, "ERC3156FlashLender: _newFee should <= MAX_FEE_BPS");

        // set new flash fee
        uint256 _oldFee = feeBps;
        feeBps = uint16(_newFee);
        emit FlashFeeSet(msg.sender, _oldFee, _newFee);
    }

    /// @notice Should Flashloans be paused?
    function setFlashLoansPaused(bool _paused) external requiresAuth {
        ICdpManagerData(cdpManagerAddress).syncGlobalAccountingAndGracePeriod(); // Accrue State First

        flashLoansPaused = _paused;
        emit FlashLoansPaused(msg.sender, _paused);
    }
}


Lines covered:	247 / 332 (74.4%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./Interfaces/IBorrowerOperations.sol";
import "./Interfaces/ICdpManager.sol";
import "./Interfaces/ICdpManagerData.sol";
import "./Interfaces/IEBTCToken.sol";
import "./Interfaces/ICollSurplusPool.sol";
import "./Interfaces/ISortedCdps.sol";
import "./Dependencies/LiquityBase.sol";
import "./Dependencies/ReentrancyGuard.sol";
import "./Dependencies/Ownable.sol";
import "./Dependencies/AuthNoOwner.sol";
import "./Dependencies/ERC3156FlashLender.sol";
import "./Dependencies/PermitNonce.sol";

contract BorrowerOperations is
    LiquityBase,
    ReentrancyGuard,
    IBorrowerOperations,
    ERC3156FlashLender,
    AuthNoOwner,
    PermitNonce
{
    string public constant NAME = "BorrowerOperations";

    // keccak256("permitPositionManagerApproval(address borrower,address positionManager,uint8 status,uint256 nonce,uint256 deadline)");
    bytes32 private constant _PERMIT_POSITION_MANAGER_TYPEHASH =
        keccak256(
            "PermitPositionManagerApproval(address borrower,address positionManager,uint8 status,uint256 nonce,uint256 deadline)"
        );

    // keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
    bytes32 private constant _TYPE_HASH =
        0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;

    string internal constant _VERSION = "1";

    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;

    // --- Connected contract declarations ---

    ICdpManager public immutable cdpManager;

    ICollSurplusPool public immutable collSurplusPool;

    address public feeRecipientAddress;

    IEBTCToken public immutable ebtcToken;

    // A doubly linked list of Cdps, sorted by their collateral ratios
    ISortedCdps public immutable sortedCdps;

    // Mapping of borrowers to approved position managers, by approval status: cdpOwner(borrower) -> positionManager -> PositionManagerApproval (None, OneTime, Persistent)
    mapping(address => mapping(address => PositionManagerApproval)) public positionManagers;

    /* --- Variable container structs  ---

    Used to hold, return and assign variables inside a function, in order to avoid the error:
    "CompilerError: Stack too deep". */

    struct LocalVariables_adjustCdp {
        uint256 price;
        uint256 collChange;
        uint256 netDebtChange;
        bool isCollIncrease;
        uint256 debt;
        uint256 coll;
        uint256 oldICR;
        uint256 newICR;
        uint256 newTCR;
        uint256 newDebt;
        uint256 newColl;
        uint256 stake;
    }

    struct LocalVariables_openCdp {
        uint256 price;
        uint256 debt;
        uint256 totalColl;
        uint256 netColl;
        uint256 ICR;
        uint256 NICR;
        uint256 stake;
        uint256 arrayIndex;
    }

    struct LocalVariables_moveTokens {
        address user;
        uint256 collChange;
        uint256 collAddUnderlying; // ONLY for isCollIncrease=true
        bool isCollIncrease;
        uint256 EBTCChange;
        bool isDebtIncrease;
        uint256 netDebtChange;
    }

    // --- Dependency setters ---
    constructor(
        address _cdpManagerAddress,
        address _activePoolAddress,
        address _collSurplusPoolAddress,
        address _priceFeedAddress,
        address _sortedCdpsAddress,
        address _ebtcTokenAddress,
        address _feeRecipientAddress,
        address _collTokenAddress
    ) LiquityBase(_activePoolAddress, _priceFeedAddress, _collTokenAddress) {
        // This makes impossible to open a cdp with zero withdrawn EBTC
        // TODO: Re-evaluate this

        cdpManager = ICdpManager(_cdpManagerAddress);
        collSurplusPool = ICollSurplusPool(_collSurplusPoolAddress);
        sortedCdps = ISortedCdps(_sortedCdpsAddress);
        ebtcToken = IEBTCToken(_ebtcTokenAddress);
        feeRecipientAddress = _feeRecipientAddress;

        address _authorityAddress = address(AuthNoOwner(_cdpManagerAddress).authority());
        if (_authorityAddress != address(0)) {
            _initializeAuthority(_authorityAddress);
        }

        bytes32 hashedName = keccak256(bytes(NAME));
        bytes32 hashedVersion = keccak256(bytes(_VERSION));

        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = _chainID();
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(_TYPE_HASH, hashedName, hashedVersion);

        emit FeeRecipientAddressChanged(_feeRecipientAddress);
    }

    /**
        @notice BorrowerOperations and CdpManager share reentrancy status by confirming the other's locked flag before beginning operation
        @dev This is an alternative to the more heavyweight solution of both being able to set the reentrancy flag on a 3rd contract.
        @dev Prevents multi-contract reentrancy between these two contracts
     */
    modifier nonReentrantSelfAndCdpM() {
        require(locked == OPEN, "BorrowerOperations: Reentrancy in nonReentrant call");
        require(
            ReentrancyGuard(address(cdpManager)).locked() == OPEN,
            "CdpManager: Reentrancy in nonReentrant call"
        );

        locked = LOCKED;

        _;

        locked = OPEN;
    }

    // --- Borrower Cdp Operations ---

    /**
    @notice Function that creates a Cdp for the caller with the requested debt, and the stETH received as collateral.
    @notice Successful execution is conditional mainly on the resulting collateralization ratio which must exceed the minimum (110% in Normal Mode, 150% in Recovery Mode).
    @notice In addition to the requested debt, extra debt is issued to cover the gas compensation.
    */
    function openCdp(
        uint256 _EBTCAmount,
        bytes32 _upperHint,
        bytes32 _lowerHint,
        uint256 _stEthBalance
    ) external override nonReentrantSelfAndCdpM returns (bytes32) {
        return _openCdp(_EBTCAmount, _upperHint, _lowerHint, _stEthBalance, msg.sender);
    }

    function openCdpFor(
        uint256 _EBTCAmount,
        bytes32 _upperHint,
        bytes32 _lowerHint,
        uint256 _collAmount,
        address _borrower
    ) external override nonReentrantSelfAndCdpM returns (bytes32) {
        return _openCdp(_EBTCAmount, _upperHint, _lowerHint, _collAmount, _borrower);
    }

    // Function that adds the received stETH to the caller's specified Cdp.
    function addColl(
        bytes32 _cdpId,
        bytes32 _upperHint,
        bytes32 _lowerHint,
        uint256 _stEthBalanceIncrease
    ) external override nonReentrantSelfAndCdpM {
        _adjustCdpInternal(_cdpId, 0, 0, false, _upperHint, _lowerHint, _stEthBalanceIncrease);
    }

    /**
    Withdraws `_stEthBalanceDecrease` amount of collateral from the caller’s Cdp. Executes only if the user has an active Cdp, the withdrawal would not pull the user’s Cdp below the minimum collateralization ratio, and the resulting total collateralization ratio of the system is above 150%.
    */
    function withdrawColl(
        bytes32 _cdpId,
        uint256 _stEthBalanceDecrease,
        bytes32 _upperHint,
        bytes32 _lowerHint
    ) external override nonReentrantSelfAndCdpM {
        _adjustCdpInternal(_cdpId, _stEthBalanceDecrease, 0, false, _upperHint, _lowerHint, 0);
    }

    // Withdraw EBTC tokens from a cdp: mint new EBTC tokens to the owner, and increase the cdp's debt accordingly
    /**
    Issues `_amount` of eBTC from the caller’s Cdp to the caller. Executes only if the Cdp's collateralization ratio would remain above the minimum, and the resulting total collateralization ratio is above 150%.
     */
    function withdrawEBTC(
        bytes32 _cdpId,
        uint256 _EBTCAmount,
        bytes32 _upperHint,
        bytes32 _lowerHint
    ) external override nonReentrantSelfAndCdpM {
        _adjustCdpInternal(_cdpId, 0, _EBTCAmount, true, _upperHint, _lowerHint, 0);
    }

    // Repay EBTC tokens to a Cdp: Burn the repaid EBTC tokens, and reduce the cdp's debt accordingly
    /**
    repay `_amount` of eBTC to the caller’s Cdp, subject to leaving 50 debt in the Cdp (which corresponds to the 50 eBTC gas compensation).
    */
    function repayEBTC(
        bytes32 _cdpId,
        uint256 _EBTCAmount,
        bytes32 _upperHint,
        bytes32 _lowerHint
    ) external override nonReentrantSelfAndCdpM {
        _adjustCdpInternal(_cdpId, 0, _EBTCAmount, false, _upperHint, _lowerHint, 0);
    }

    function adjustCdp(
        bytes32 _cdpId,
        uint256 _stEthBalanceDecrease,
        uint256 _EBTCChange,
        bool _isDebtIncrease,
        bytes32 _upperHint,
        bytes32 _lowerHint
    ) external override nonReentrantSelfAndCdpM {
        _adjustCdpInternal(
            _cdpId,
            _stEthBalanceDecrease,
            _EBTCChange,
            _isDebtIncrease,
            _upperHint,
            _lowerHint,
            0
        );
    }

    /**
    enables a borrower to simultaneously change both their collateral and debt, subject to all the restrictions that apply to individual increases/decreases of each quantity with the following particularity: if the adjustment reduces the collateralization ratio of the Cdp, the function only executes if the resulting total collateralization ratio is above 150%. The borrower has to provide a `_maxFeePercentage` that he/she is willing to accept in case of a fee slippage, i.e. when a redemption transaction is processed first, driving up the issuance fee. The parameter is ignored if the debt is not increased with the transaction.
    */
    // TODO optimization candidate
    function adjustCdpWithColl(
        bytes32 _cdpId,
        uint256 _stEthBalanceDecrease,
        uint256 _EBTCChange,
        bool _isDebtIncrease,
        bytes32 _upperHint,
        bytes32 _lowerHint,
        uint256 _stEthBalanceIncrease
    ) external override nonReentrantSelfAndCdpM {
        _adjustCdpInternal(
            _cdpId,
            _stEthBalanceDecrease,
            _EBTCChange,
            _isDebtIncrease,
            _upperHint,
            _lowerHint,
            _stEthBalanceIncrease
        );
    }

    /*
     * _adjustCdpInternal(): Alongside a debt change, this function can perform either
     * a collateral top-up or a collateral withdrawal.
     *
     * It therefore expects either a positive _stEthBalanceIncrease, or a positive _stEthBalanceDecrease argument.
     *
     * If both are positive, it will revert.
     */
    function _adjustCdpInternal(
        bytes32 _cdpId,
        uint256 _stEthBalanceDecrease,
        uint256 _EBTCChange,
        bool _isDebtIncrease,
        bytes32 _upperHint,
        bytes32 _lowerHint,
        uint256 _stEthBalanceIncrease
    ) internal {
        // Confirm the operation is the borrower or approved position manager adjusting its own cdp
        address _borrower = sortedCdps.getOwnerAddress(_cdpId);
        _requireBorrowerOrPositionManagerAndUpdate(_borrower);

        _requireCdpisActive(cdpManager, _cdpId);

        cdpManager.syncAccounting(_cdpId);

        LocalVariables_adjustCdp memory vars;

        vars.price = priceFeed.fetchPrice();
        bool isRecoveryMode = _checkRecoveryModeForTCR(_getTCR(vars.price));

        if (_isDebtIncrease) {
            _requireNonZeroDebtChange(_EBTCChange);
        }
        _requireSingularCollChange(_stEthBalanceIncrease, _stEthBalanceDecrease);
        _requireNonZeroAdjustment(_stEthBalanceIncrease, _stEthBalanceDecrease, _EBTCChange);

        // Get the collChange based on the collateral value transferred in the transaction
        (vars.collChange, vars.isCollIncrease) = _getCollSharesChangeFromStEthChange(
            _stEthBalanceIncrease,
            _stEthBalanceDecrease
        );

        vars.netDebtChange = _EBTCChange;

        vars.debt = cdpManager.getCdpDebt(_cdpId);
        vars.coll = cdpManager.getCdpCollShares(_cdpId);

        // Get the cdp's old ICR before the adjustment, and what its new ICR will be after the adjustment
        uint256 _cdpStEthBalance = collateral.getPooledEthByShares(vars.coll);
        require(
            _stEthBalanceDecrease <= _cdpStEthBalance,
            "BorrowerOperations: withdraw more collateral than CDP has!"
        );
        vars.oldICR = LiquityMath._computeCR(_cdpStEthBalance, vars.debt, vars.price);
        vars.newICR = _getNewICRFromCdpChange(
            vars.coll,
            vars.debt,
            vars.collChange,
            vars.isCollIncrease,
            vars.netDebtChange,
            _isDebtIncrease,
            vars.price
        );

        // Check the adjustment satisfies all conditions for the current system mode
        _requireValidAdjustmentInCurrentMode(
            isRecoveryMode,
            _stEthBalanceDecrease,
            _isDebtIncrease,
            vars
        );

        // When the adjustment is a debt repayment, check it's a valid amount, that the caller has enough EBTC, and that the resulting debt is >0
        if (!_isDebtIncrease && _EBTCChange > 0) {
            _requireValidEBTCRepayment(vars.debt, vars.netDebtChange);
            _requireSufficientEBTCBalance(ebtcToken, msg.sender, vars.netDebtChange);
            _requireNonZeroDebt(vars.debt - vars.netDebtChange);
        }

        (vars.newColl, vars.newDebt) = _getNewCdpAmounts(
            vars.coll,
            vars.debt,
            vars.collChange,
            vars.isCollIncrease,
            vars.netDebtChange,
            _isDebtIncrease
        );

        _requireAtLeastMinNetStEthBalance(collateral.getPooledEthByShares(vars.newColl));

        cdpManager.updateCdp(_cdpId, _borrower, vars.coll, vars.debt, vars.newColl, vars.newDebt);

        // Re-insert cdp in to the sorted list
        {
            uint256 newNICR = _getNewNominalICRFromCdpChange(vars, _isDebtIncrease);
            sortedCdps.reInsert(_cdpId, newNICR, _upperHint, _lowerHint);
        }

        // Use the unmodified _EBTCChange here, as we don't send the fee to the user
        {
            LocalVariables_moveTokens memory _varMvTokens = LocalVariables_moveTokens(
                msg.sender,
                vars.collChange,
                (vars.isCollIncrease ? _stEthBalanceIncrease : 0),
                vars.isCollIncrease,
                _EBTCChange,
                _isDebtIncrease,
                vars.netDebtChange
            );
            _processTokenMovesFromAdjustment(_varMvTokens);
        }
    }

    function _openCdp(
        uint256 _EBTCAmount,
        bytes32 _upperHint,
        bytes32 _lowerHint,
        uint256 _stEthBalance,
        address _borrower
    ) internal returns (bytes32) {
        _requireNonZeroDebt(_EBTCAmount);
        _requireBorrowerOrPositionManagerAndUpdate(_borrower);

        LocalVariables_openCdp memory vars;

        // ICR is based on the net coll, i.e. the requested coll amount - fixed liquidator incentive gas comp.
        vars.netColl = _getNetColl(_stEthBalance);

        // will revert if _stEthBalance is less than MIN_NET_COLL + LIQUIDATOR_REWARD
        _requireAtLeastMinNetStEthBalance(vars.netColl);

        // Update global pending index before any operations
        cdpManager.syncGlobalAccounting();

        vars.price = priceFeed.fetchPrice();
        bool isRecoveryMode = _checkRecoveryModeForTCR(_getTCR(vars.price));

        vars.debt = _EBTCAmount;

        // Sanity check
        require(vars.netColl > 0, "BorrowerOperations: zero collateral for openCdp()!");

        uint256 _netCollAsShares = collateral.getSharesByPooledEth(vars.netColl);
        uint256 _liquidatorRewardShares = collateral.getSharesByPooledEth(LIQUIDATOR_REWARD);

        // ICR is based on the net coll, i.e. the requested coll amount - fixed liquidator incentive gas comp.
        vars.ICR = LiquityMath._computeCR(vars.netColl, vars.debt, vars.price);

        // NICR uses shares to normalize NICR across CDPs opened at different pooled ETH / shares ratios
        vars.NICR = LiquityMath._computeNominalCR(_netCollAsShares, vars.debt);

        /**
            In recovery move, ICR must be greater than CCR
            CCR > MCR (125% vs 110%)

            In normal mode, ICR must be greater thatn MCR
            Additionally, the new system TCR after the CDPs addition must be >CCR
        */
        uint256 newTCR = _getNewTCRFromCdpChange(vars.netColl, true, vars.debt, true, vars.price);
        if (isRecoveryMode) {
            _requireICRisAboveCCR(vars.ICR);

            // == Grace Period == //
            // We are in RM, Edge case is Depositing Coll could exit RM
            // We check with newTCR
            if (newTCR < CCR) {
                // Notify RM
                cdpManager.notifyStartGracePeriod(newTCR);
            } else {
                // Notify Back to Normal Mode
                cdpManager.notifyEndGracePeriod(newTCR);
            }
        } else {
            _requireICRisAboveMCR(vars.ICR);
            _requireNewTCRisAboveCCR(newTCR);

            // == Grace Period == //
            // We are not in RM, no edge case, we always stay above RM
            // Always Notify Back to Normal Mode
            cdpManager.notifyEndGracePeriod(newTCR);
        }

        // Set the cdp struct's properties
        bytes32 _cdpId = sortedCdps.insert(_borrower, vars.NICR, _upperHint, _lowerHint);

        // Collision check: collisions should never occur
        // Explicitly prevent it by checking for `nonExistent`
        _requireCdpIsNonExistent(_cdpId);

        // Collateral is stored in shares form for normalization
        cdpManager.initializeCdp(
            _cdpId,
            vars.debt,
            _netCollAsShares,
            _liquidatorRewardShares,
            _borrower
        );

        // Mint the full EBTCAmount to the caller
        _withdrawEBTC(msg.sender, _EBTCAmount, _EBTCAmount);

        /**
            Note that only NET coll (as shares) is considered part of the CDP.
            The static liqudiation incentive is stored in the gas pool and can be considered a deposit / voucher to be returned upon CDP close, to the closer.
            The close can happen from the borrower closing their own CDP, a full liquidation, or a redemption.
        */

        // CEI: Move the net collateral and liquidator gas compensation to the Active Pool. Track only net collateral shares for TCR purposes.
        _activePoolAddColl(_stEthBalance, _netCollAsShares);

        // Invariant check
        require(
            vars.netColl + LIQUIDATOR_REWARD == _stEthBalance,
            "BorrowerOperations: deposited collateral mismatch!"
        );

        return _cdpId;
    }

    /**
    allows a borrower to repay all debt, withdraw all their collateral, and close their Cdp. Requires the borrower have a eBTC balance sufficient to repay their cdp's debt, excluding gas compensation - i.e. `(debt - 50)` eBTC.
    */
    function closeCdp(bytes32 _cdpId) external override {
        address _borrower = sortedCdps.getOwnerAddress(_cdpId);
        _requireBorrowerOrPositionManagerAndUpdate(_borrower);

        _requireCdpisActive(cdpManager, _cdpId);

        cdpManager.syncAccounting(_cdpId);

        uint256 price = priceFeed.fetchPrice();
        _requireNotInRecoveryMode(_getTCR(price));

        uint256 coll = cdpManager.getCdpCollShares(_cdpId);
        uint256 debt = cdpManager.getCdpDebt(_cdpId);
        uint256 liquidatorRewardShares = cdpManager.getCdpLiquidatorRewardShares(_cdpId);

        _requireSufficientEBTCBalance(ebtcToken, msg.sender, debt);

        uint256 newTCR = _getNewTCRFromCdpChange(
            collateral.getPooledEthByShares(coll),
            false,
            debt,
            false,
            price
        );
        _requireNewTCRisAboveCCR(newTCR);

        // == Grace Period == //
        // By definition we are not in RM, notify CDPManager to ensure "Glass is on"
        cdpManager.notifyEndGracePeriod(newTCR);

        cdpManager.removeStake(_cdpId);

        // We already verified msg.sender is the borrower
        cdpManager.closeCdp(_cdpId, msg.sender, debt, coll);

        // Burn the repaid EBTC from the user's balance
        _repayEBTC(msg.sender, debt);

        // CEI: Send the collateral and liquidator reward shares back to the user
        activePool.transferSystemCollSharesAndLiquidatorReward(
            msg.sender,
            coll,
            liquidatorRewardShares
        );
    }

    /**
     * Claim remaining collateral from a redemption or from a liquidation with ICR > MCR in Recovery Mode

      when a borrower’s Cdp has been fully redeemed from and closed, or liquidated in Recovery Mode with a collateralization ratio above 110%, this function allows the borrower to claim their stETH collateral surplus that remains in the system (collateral - debt upon redemption; collateral - 110% of the debt upon liquidation).
     */
    function claimSurplusCollShares() external override {
        // send ETH from CollSurplus Pool to owner
        collSurplusPool.claimSurplusCollShares(msg.sender);
    }

    /// @notice Returns true if the borrower is allowing position manager to act on their behalf
    function getPositionManagerApproval(
        address _borrower,
        address _positionManager
    ) external view override returns (PositionManagerApproval) {
        return _getPositionManagerApproval(_borrower, _positionManager);
    }

    function _getPositionManagerApproval(
        address _borrower,
        address _positionManager
    ) internal view returns (PositionManagerApproval) {
        return positionManagers[_borrower][_positionManager];
    }

    /// @notice Approve an account to take arbitrary actions on your Cdps.
    /// @notice Account managers with 'Persistent' status will be able to take actions indefinitely
    /// @notice Account managers with 'OneTIme' status will be able to take a single action on one Cdp. Approval will be automatically revoked after one Cdp-related action.
    /// @notice Similar to approving tokens, approving a position manager allows _stealing of all positions_ if given to a malicious account.
    function setPositionManagerApproval(
        address _positionManager,
        PositionManagerApproval _approval
    ) external override {
        _setPositionManagerApproval(msg.sender, _positionManager, _approval);
    }

    function _setPositionManagerApproval(
        address _borrower,
        address _positionManager,
        PositionManagerApproval _approval
    ) internal {
        positionManagers[_borrower][_positionManager] = _approval;
        emit PositionManagerApprovalSet(_borrower, _positionManager, _approval);
    }

    /// @notice Revoke a position manager from taking further actions on your Cdps
    /// @notice Similar to approving tokens, approving a position manager allows _stealing of all positions_ if given to a malicious account.
    function revokePositionManagerApproval(address _positionManager) external override {
        _setPositionManagerApproval(msg.sender, _positionManager, PositionManagerApproval.None);
    }

    /// @notice Allows recipient of delegation to renounce it
    function renouncePositionManagerApproval(address _borrower) external override {
        _setPositionManagerApproval(_borrower, msg.sender, PositionManagerApproval.None);
    }

    function DOMAIN_SEPARATOR() external view returns (bytes32) {
        return domainSeparator();
    }

    function domainSeparator() public view override returns (bytes32) {
        if (_chainID() == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _chainID() private view returns (uint256) {
        return block.chainid;
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 name,
        bytes32 version
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, name, version, _chainID(), address(this)));
    }

    function version() external pure override returns (string memory) {
        return _VERSION;
    }

    function permitTypeHash() external pure override returns (bytes32) {
        return _PERMIT_POSITION_MANAGER_TYPEHASH;
    }

    function permitPositionManagerApproval(
        address _borrower,
        address _positionManager,
        PositionManagerApproval _approval,
        uint256 _deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external override {
        require(_deadline >= block.timestamp, "BorrowerOperations: Position manager permit expired");

        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                domainSeparator(),
                keccak256(
                    abi.encode(
                        _PERMIT_POSITION_MANAGER_TYPEHASH,
                        _borrower,
                        _positionManager,
                        _approval,
                        _nonces[_borrower]++,
                        _deadline
                    )
                )
            )
        );
        address recoveredAddress = ecrecover(digest, v, r, s);
        require(
            recoveredAddress != address(0) && recoveredAddress == _borrower,
            "BorrowerOperations: Invalid signature"
        );

        _setPositionManagerApproval(_borrower, _positionManager, _approval);
    }

    // --- Helper functions ---

    function _getCollSharesChangeFromStEthChange(
        uint256 _collReceived,
        uint256 _requestedCollWithdrawal
    ) internal view returns (uint256 collChange, bool isCollIncrease) {
        if (_collReceived != 0) {
            collChange = collateral.getSharesByPooledEth(_collReceived);
            isCollIncrease = true;
        } else {
            collChange = collateral.getSharesByPooledEth(_requestedCollWithdrawal);
        }
    }

    /**
        @notice Process the token movements required by a CDP adjustment.
        @notice Handles the cases of a debt increase / decrease, and/or a collateral increase / decrease.
     */
    function _processTokenMovesFromAdjustment(
        LocalVariables_moveTokens memory _varMvTokens
    ) internal {
        // Debt increase: mint change value of new eBTC to user, increment ActivePool eBTC internal accounting
        if (_varMvTokens.isDebtIncrease) {
            _withdrawEBTC(_varMvTokens.user, _varMvTokens.EBTCChange, _varMvTokens.netDebtChange);
        } else {
            // Debt decrease: burn change value of eBTC from user, decrement ActivePool eBTC internal accounting
            _repayEBTC(_varMvTokens.user, _varMvTokens.EBTCChange);
        }

        if (_varMvTokens.isCollIncrease) {
            // Coll increase: send change value of stETH to Active Pool, increment ActivePool stETH internal accounting
            _activePoolAddColl(_varMvTokens.collAddUnderlying, _varMvTokens.collChange);
        } else {
            // Coll decrease: send change value of stETH to user, decrement ActivePool stETH internal accounting
            activePool.transferSystemCollShares(_varMvTokens.user, _varMvTokens.collChange);
        }
    }

    /// @notice Send stETH to Active Pool and increase its recorded ETH balance
    /// @param _stEthBalance total balance of stETH to send, inclusive of coll and liquidatorRewardShares
    /// @param _sharesToTrack coll as shares (exclsuive of liquidator reward shares)
    /// @dev Liquidator reward shares are not considered as part of the system for CR purposes.
    /// @dev These number of liquidator shares associated with each CDP are stored in the CDP, while the actual tokens float in the active pool
    function _activePoolAddColl(uint256 _stEthBalance, uint256 _sharesToTrack) internal {
        // NOTE: No need for safe transfer if the collateral asset is standard. Make sure this is the case!
        collateral.transferFrom(msg.sender, address(activePool), _stEthBalance);
        activePool.increaseSystemCollShares(_sharesToTrack);
    }

    // Issue the specified amount of EBTC to _account and increases
    // the total active debt
    function _withdrawEBTC(
        address _account,
        uint256 _EBTCAmount,
        uint256 _netDebtIncrease
    ) internal {
        activePool.increaseSystemDebt(_netDebtIncrease);
        ebtcToken.mint(_account, _EBTCAmount);
    }

    // Burn the specified amount of EBTC from _account and decreases the total active debt
    function _repayEBTC(address _account, uint256 _EBTC) internal {
        activePool.decreaseSystemDebt(_EBTC);
        ebtcToken.burn(_account, _EBTC);
    }

    // --- 'Require' wrapper functions ---

    function _requireSingularCollChange(
        uint256 _stEthBalanceIncrease,
        uint256 _stEthBalanceDecrease
    ) internal pure {
        require(
            _stEthBalanceIncrease == 0 || _stEthBalanceDecrease == 0,
            "BorrowerOperations: Cannot add and withdraw collateral in same operation"
        );
    }

    function _requireNonZeroAdjustment(
        uint256 _stEthBalanceIncrease,
        uint256 _EBTCChange,
        uint256 _stEthBalanceDecrease
    ) internal pure {
        require(
            _stEthBalanceIncrease != 0 || _stEthBalanceDecrease != 0 || _EBTCChange != 0,
            "BorrowerOperations: There must be either a collateral change or a debt change"
        );
    }

    function _requireCdpisActive(ICdpManager _cdpManager, bytes32 _cdpId) internal view {
        uint256 status = _cdpManager.getCdpStatus(_cdpId);
        require(status == 1, "BorrowerOperations: Cdp does not exist or is closed");
    }

    function _requireCdpIsNonExistent(bytes32 _cdpId) internal view {
        uint status = cdpManager.getCdpStatus(_cdpId);
        require(status == 0, "BorrowerOperations: Cdp is active or has been previously closed");
    }

    function _requireNonZeroDebtChange(uint _EBTCChange) internal pure {
        require(_EBTCChange > 0, "BorrowerOperations: Debt increase requires non-zero debtChange");
    }

    function _requireNotInRecoveryMode(uint256 _tcr) internal view {
        require(
            !_checkRecoveryModeForTCR(_tcr),
            "BorrowerOperations: Operation not permitted during Recovery Mode"
        );
    }

    function _requireNoStEthBalanceDecrease(uint256 _stEthBalanceDecrease) internal pure {
        require(
            _stEthBalanceDecrease == 0,
            "BorrowerOperations: Collateral withdrawal not permitted Recovery Mode"
        );
    }

    function _requireValidAdjustmentInCurrentMode(
        bool _isRecoveryMode,
        uint256 _stEthBalanceDecrease,
        bool _isDebtIncrease,
        LocalVariables_adjustCdp memory _vars
    ) internal {
        /*
         *In Recovery Mode, only allow:
         *
         * - Pure collateral top-up
         * - Pure debt repayment
         * - Collateral top-up with debt repayment
         * - A debt increase combined with a collateral top-up which makes the
         * ICR >= 150% and improves the ICR (and by extension improves the TCR).
         *
         * In Normal Mode, ensure:
         *
         * - The new ICR is above MCR
         * - The adjustment won't pull the TCR below CCR
         */

        _vars.newTCR = _getNewTCRFromCdpChange(
            collateral.getPooledEthByShares(_vars.collChange),
            _vars.isCollIncrease,
            _vars.netDebtChange,
            _isDebtIncrease,
            _vars.price
        );

        if (_isRecoveryMode) {
            _requireNoStEthBalanceDecrease(_stEthBalanceDecrease);
            if (_isDebtIncrease) {
                _requireICRisAboveCCR(_vars.newICR);
                _requireNewICRisAboveOldICR(_vars.newICR, _vars.oldICR);
            }

            // == Grace Period == //
            // We are in RM, Edge case is Depositing Coll could exit RM
            // We check with newTCR
            if (_vars.newTCR < CCR) {
                // Notify RM
                cdpManager.notifyStartGracePeriod(_vars.newTCR);
            } else {
                // Notify Back to Normal Mode
                cdpManager.notifyEndGracePeriod(_vars.newTCR);
            }
        } else {
            // if Normal Mode
            _requireICRisAboveMCR(_vars.newICR);
            _requireNewTCRisAboveCCR(_vars.newTCR);

            // == Grace Period == //
            // We are not in RM, no edge case, we always stay above RM
            // Always Notify Back to Normal Mode
            cdpManager.notifyEndGracePeriod(_vars.newTCR);
        }
    }

    function _requireICRisAboveMCR(uint256 _newICR) internal pure {
        require(
            _newICR >= MCR,
            "BorrowerOperations: An operation that would result in ICR < MCR is not permitted"
        );
    }

    function _requireICRisAboveCCR(uint256 _newICR) internal pure {
        require(_newICR >= CCR, "BorrowerOperations: Operation must leave cdp with ICR >= CCR");
    }

    function _requireNewICRisAboveOldICR(uint256 _newICR, uint256 _oldICR) internal pure {
        require(
            _newICR >= _oldICR,
            "BorrowerOperations: Cannot decrease your Cdp's ICR in Recovery Mode"
        );
    }

    function _requireNewTCRisAboveCCR(uint256 _newTCR) internal pure {
        require(
            _newTCR >= CCR,
            "BorrowerOperations: An operation that would result in TCR < CCR is not permitted"
        );
    }

    function _requireNonZeroDebt(uint256 _debt) internal pure {
        require(_debt > 0, "BorrowerOperations: Debt must be non-zero");
    }

    function _requireAtLeastMinNetStEthBalance(uint256 _coll) internal pure {
        require(
            _coll >= MIN_NET_COLL,
            "BorrowerOperations: Cdp's net coll must be greater than minimum"
        );
    }

    function _requireValidEBTCRepayment(uint256 _currentDebt, uint256 _debtRepayment) internal pure {
        require(
            _debtRepayment <= _currentDebt,
            "BorrowerOperations: Amount repaid must not be larger than the Cdp's debt"
        );
    }

    function _requireSufficientEBTCBalance(
        IEBTCToken _ebtcToken,
        address _account,
        uint256 _debtRepayment
    ) internal view {
        require(
            _ebtcToken.balanceOf(_account) >= _debtRepayment,
            "BorrowerOperations: Caller doesnt have enough EBTC to make repayment"
        );
    }

    function _requireBorrowerOrPositionManagerAndUpdate(address _borrower) internal {
        if (_borrower == msg.sender) {
            return; // Early return, no delegation
        }

        PositionManagerApproval _approval = _getPositionManagerApproval(_borrower, msg.sender);
        // Must be an approved position manager at this point
        require(
            _approval != PositionManagerApproval.None,
            "BorrowerOperations: Only borrower account or approved position manager can OpenCdp on borrower's behalf"
        );

        // Conditional Adjustment
        /// @dev If this is a position manager operation with a one-time approval, clear that approval
        /// @dev If the PositionManagerApproval was none, we should have failed with the check in _requireBorrowerOrPositionManagerAndUpdate
        if (_approval == PositionManagerApproval.OneTime) {
            _setPositionManagerApproval(_borrower, msg.sender, PositionManagerApproval.None);
        }
    }

    // --- ICR and TCR getters ---

    // Compute the new collateral ratio, considering the change in coll and debt. Assumes 0 pending rewards.
    function _getNewNominalICRFromCdpChange(
        LocalVariables_adjustCdp memory vars,
        bool _isDebtIncrease
    ) internal pure returns (uint256) {
        (uint256 newColl, uint256 newDebt) = _getNewCdpAmounts(
            vars.coll,
            vars.debt,
            vars.collChange,
            vars.isCollIncrease,
            vars.netDebtChange,
            _isDebtIncrease
        );

        uint256 newNICR = LiquityMath._computeNominalCR(newColl, newDebt);
        return newNICR;
    }

    // Compute the new collateral ratio, considering the change in coll and debt. Assumes 0 pending rewards.
    function _getNewICRFromCdpChange(
        uint256 _coll,
        uint256 _debt,
        uint256 _collChange,
        bool _isCollIncrease,
        uint256 _debtChange,
        bool _isDebtIncrease,
        uint256 _price
    ) internal view returns (uint256) {
        (uint256 newColl, uint256 newDebt) = _getNewCdpAmounts(
            _coll,
            _debt,
            _collChange,
            _isCollIncrease,
            _debtChange,
            _isDebtIncrease
        );

        uint256 newICR = LiquityMath._computeCR(
            collateral.getPooledEthByShares(newColl),
            newDebt,
            _price
        );
        return newICR;
    }

    function _getNewCdpAmounts(
        uint256 _coll,
        uint256 _debt,
        uint256 _collChange,
        bool _isCollIncrease,
        uint256 _debtChange,
        bool _isDebtIncrease
    ) internal pure returns (uint256, uint256) {
        uint256 newColl = _coll;
        uint256 newDebt = _debt;

        newColl = _isCollIncrease ? _coll + _collChange : _coll - _collChange;
        newDebt = _isDebtIncrease ? _debt + _debtChange : _debt - _debtChange;

        return (newColl, newDebt);
    }

    function _getNewTCRFromCdpChange(
        uint256 _collChange,
        bool _isCollIncrease,
        uint256 _debtChange,
        bool _isDebtIncrease,
        uint256 _price
    ) internal view returns (uint256) {
        uint256 _shareColl = getSystemCollShares();
        uint256 totalColl = collateral.getPooledEthByShares(_shareColl);
        uint256 totalDebt = _getSystemDebt();

        totalColl = _isCollIncrease ? totalColl + _collChange : totalColl - _collChange;
        totalDebt = _isDebtIncrease ? totalDebt + _debtChange : totalDebt - _debtChange;

        uint256 newTCR = LiquityMath._computeCR(totalColl, totalDebt, _price);
        return newTCR;
    }

    // === Flash Loans === //
    function flashLoan(
        IERC3156FlashBorrower receiver,
        address token,
        uint256 amount,
        bytes calldata data
    ) external override returns (bool) {
        require(amount > 0, "BorrowerOperations: 0 Amount");
        uint256 fee = flashFee(token, amount); // NOTE: Check for `eBTCToken` is implicit here // NOTE: Pause check is here
        require(amount <= maxFlashLoan(token), "BorrowerOperations: Too much");

        // Issue EBTC
        ebtcToken.mint(address(receiver), amount);

        // Callback
        require(
            receiver.onFlashLoan(msg.sender, token, amount, fee, data) == FLASH_SUCCESS_VALUE,
            "IERC3156: Callback failed"
        );

        // Gas: Repay from user balance, so we don't trigger a new SSTORE
        // Safe to use transferFrom and unchecked as it's a standard token
        // Also saves gas
        // Send both fee and amount to FEE_RECIPIENT, to burn allowance per EIP-3156
        ebtcToken.transferFrom(address(receiver), feeRecipientAddress, fee + amount);

        // Burn amount, from FEE_RECIPIENT
        ebtcToken.burn(feeRecipientAddress, amount);

        emit FlashLoanSuccess(address(receiver), token, amount, fee);

        return true;
    }

    function flashFee(address token, uint256 amount) public view override returns (uint256) {
        require(token == address(ebtcToken), "BorrowerOperations: EBTC Only");
        require(!flashLoansPaused, "BorrowerOperations: Flash Loans Paused");

        return (amount * feeBps) / MAX_BPS;
    }

    /// @dev Max flashloan, exclusively in ETH equals to the current balance
    function maxFlashLoan(address token) public view override returns (uint256) {
        if (token != address(ebtcToken)) {
            return 0;
        }

        if (flashLoansPaused) {
            return 0;
        }

        return type(uint112).max;
    }

    // === Governed Functions ==

    function setFeeRecipientAddress(address _feeRecipientAddress) external requiresAuth {
        require(
            _feeRecipientAddress != address(0),
            "BorrowerOperations: Cannot set feeRecipient to zero address"
        );

        cdpManager.syncGlobalAccounting();

        feeRecipientAddress = _feeRecipientAddress;
        emit FeeRecipientAddressChanged(_feeRecipientAddress);
    }

    function setFeeBps(uint256 _newFee) external requiresAuth {
        require(_newFee <= MAX_FEE_BPS, "ERC3156FlashLender: _newFee should <= MAX_FEE_BPS");

        cdpManager.syncGlobalAccounting();

        // set new flash fee
        uint256 _oldFee = feeBps;
        feeBps = uint16(_newFee);
        emit FlashFeeSet(msg.sender, _oldFee, _newFee);
    }

    function setFlashLoansPaused(bool _paused) external requiresAuth {
        cdpManager.syncGlobalAccounting();

        flashLoansPaused = _paused;
        emit FlashLoansPaused(msg.sender, _paused);
    }
}


Lines covered:	49 / 58 (84.5%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./Interfaces/IPriceFeed.sol";
import "./Interfaces/ICdpManager.sol";

/// @notice The contract allows to check real CR of CDPs
///   Acknowledgement: https://github.com/Uniswap/v3-periphery/blob/main/contracts/lens/Quoter.sol
contract CRLens {
    ICdpManager public immutable cdpManager;
    IPriceFeed public immutable priceFeed;

    constructor(address _cdpManager, address _priceFeed) {
        cdpManager = ICdpManager(_cdpManager);
        priceFeed = IPriceFeed(_priceFeed);
    }

    // == CORE FUNCTIONS == //

    /// @notice Returns the TCR of the system after the fee split
    /// @dev Call this from offChain with `eth_call` to avoid paying for gas
    function getRealTCR(bool revertValue) external returns (uint256) {
        // Synch State
        cdpManager.syncGlobalAccountingAndGracePeriod();

        // Return latest
        uint price = priceFeed.fetchPrice();
        uint256 tcr = cdpManager.getTCR(price);

        if (revertValue) {
            assembly {
                let ptr := mload(0x40)
                mstore(ptr, tcr)
                revert(ptr, 32)
            }
        }

        return tcr;
    }

    /// @notice Return the ICR of a CDP after the fee split
    /// @dev Call this from offChain with `eth_call` to avoid paying for gas
    function getRealICR(bytes32 cdpId, bool revertValue) external returns (uint256) {
        cdpManager.syncAccounting(cdpId);
        uint price = priceFeed.fetchPrice();
        uint256 icr = cdpManager.getICR(cdpId, price);

        if (revertValue) {
            assembly {
                let ptr := mload(0x40)
                mstore(ptr, icr)
                revert(ptr, 32)
            }
        }

        return icr;
    }

    /// @notice Return the ICR of a CDP after the fee split
    /// @dev Call this from offChain with `eth_call` to avoid paying for gas
    function getRealNICR(bytes32 cdpId, bool revertValue) external returns (uint256) {
        cdpManager.syncAccounting(cdpId);
        uint price = priceFeed.fetchPrice();
        uint256 icr = cdpManager.getNominalICR(cdpId);

        if (revertValue) {
            assembly {
                let ptr := mload(0x40)
                mstore(ptr, icr)
                revert(ptr, 32)
            }
        }

        return icr;
    }

    /// @dev Returns 1 if we're in RM
    function getCheckRecoveryMode(bool revertValue) external returns (uint256) {
        // Synch State
        cdpManager.syncGlobalAccountingAndGracePeriod();

        // Return latest
        uint price = priceFeed.fetchPrice();
        uint256 isRm = cdpManager.checkRecoveryMode(price) == true ? 1 : 0;

        if (revertValue) {
            assembly {
                let ptr := mload(0x40)
                mstore(ptr, isRm)
                revert(ptr, 32)
            }
        }

        return isRm;
    }

    // == REVERT LOGIC == //
    // Thanks to: https://github.com/Uniswap/v3-periphery/blob/main/contracts/lens/Quoter.sol
    // NOTE: You should never use these in prod, these are just for testing //

    function parseRevertReason(bytes memory reason) private pure returns (uint256) {
        if (reason.length != 32) {
            if (reason.length < 68) revert("Unexpected error");
            assembly {
                reason := add(reason, 0x04)
            }
            revert(abi.decode(reason, (string)));
        }
        return abi.decode(reason, (uint256));
    }

    /// @notice Returns the TCR of the system after the fee split
    /// @dev Call this from offChain with `eth_call` to avoid paying for gas
    ///     These cost more gas, there should never be a reason for you to use them beside integration with Echidna
    function quoteRealTCR() external returns (uint256) {
        try this.getRealTCR(true) {} catch (bytes memory reason) {
            return parseRevertReason(reason);
        }
    }

    /// @notice Returns the ICR of the system after the fee split
    /// @dev Call this from offChain with `eth_call` to avoid paying for gas
    ///     These cost more gas, there should never be a reason for you to use them beside integration with Echidna
    function quoteRealICR(bytes32 cdpId) external returns (uint256) {
        try this.getRealICR(cdpId, true) {} catch (bytes memory reason) {
            return parseRevertReason(reason);
        }
    }

    /// @notice Returns the NICR of the system after the fee split
    /// @dev Call this from offChain with `eth_call` to avoid paying for gas
    ///     These cost more gas, there should never be a reason for you to use them beside integration with Echidna
    function quoteRealNICR(bytes32 cdpId) external returns (uint256) {
        try this.getRealNICR(cdpId, true) {} catch (bytes memory reason) {
            return parseRevertReason(reason);
        }
    }

    /// @notice Returns whether the system is in RM after taking fee split
    /// @dev Call this from offChain with `eth_call` to avoid paying for gas
    ///     These cost more gas, there should never be a reason for you to use them beside integration with Echidna
    function quoteCheckRecoveryMode() external returns (uint256) {
        try this.getCheckRecoveryMode(true) {} catch (bytes memory reason) {
            return parseRevertReason(reason);
        }
    }
}


Lines covered:	286 / 331 (86.4%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./Interfaces/ICdpManager.sol";
import "./Interfaces/ICollSurplusPool.sol";
import "./Interfaces/IEBTCToken.sol";
import "./Interfaces/ISortedCdps.sol";
import "./Dependencies/ICollateralTokenOracle.sol";
import "./CdpManagerStorage.sol";
import "./EBTCDeployer.sol";
import "./Dependencies/Proxy.sol";

contract CdpManager is CdpManagerStorage, ICdpManager, Proxy {
    // --- Dependency setter ---

    /**
     * @notice Constructor for CdpManager contract.
     * @dev Sets up dependencies and initial staking reward split.
     * @param _liquidationLibraryAddress Address of the liquidation library.
     * @param _authorityAddress Address of the authority.
     * @param _borrowerOperationsAddress Address of BorrowerOperations.
     * @param _collSurplusPoolAddress Address of CollSurplusPool.
     * @param _ebtcTokenAddress Address of the eBTC token.
     * @param _sortedCdpsAddress Address of the SortedCDPs.
     * @param _activePoolAddress Address of the ActivePool.
     * @param _priceFeedAddress Address of the price feed.
     * @param _collTokenAddress Address of the collateral token.
     */
    constructor(
        address _liquidationLibraryAddress,
        address _authorityAddress,
        address _borrowerOperationsAddress,
        address _collSurplusPoolAddress,
        address _ebtcTokenAddress,
        address _sortedCdpsAddress,
        address _activePoolAddress,
        address _priceFeedAddress,
        address _collTokenAddress
    )
        CdpManagerStorage(
            _liquidationLibraryAddress,
            _authorityAddress,
            _borrowerOperationsAddress,
            _collSurplusPoolAddress,
            _ebtcTokenAddress,
            _sortedCdpsAddress,
            _activePoolAddress,
            _priceFeedAddress,
            _collTokenAddress
        )
    {
        stakingRewardSplit = STAKING_REWARD_SPLIT;
        // Emit initial value for analytics
        emit StakingRewardSplitSet(stakingRewardSplit);

        (uint256 _oldIndex, uint256 _newIndex) = _readStEthIndex();
        _syncStEthIndex(_oldIndex, _newIndex);
        systemStEthFeePerUnitIndex = DECIMAL_PRECISION;
    }

    // --- Getters ---

    /**
     * @notice Get the count of CDPs in the system
     * @return The number of CDPs.
     */

    function getActiveCdpsCount() external view override returns (uint256) {
        return CdpIds.length;
    }

    /**
     * @notice Get the CdpId at a given index in the CdpIds array.
     * @param _index Index of the CdpIds array.
     * @return CDP ID.
     */
    function getIdFromCdpIdsArray(uint256 _index) external view override returns (bytes32) {
        return CdpIds[_index];
    }

    // --- Cdp Liquidation functions ---
    // -----------------------------------------------------------------
    //    CDP ICR     |       Liquidation Behavior (TODO gas compensation?)
    //
    //  < MCR         |  debt could be fully repaid by liquidator
    //                |  and ALL collateral transferred to liquidator
    //                |  OR debt could be partially repaid by liquidator and
    //                |  liquidator could get collateral of (repaidDebt * max(LICR, min(ICR, MCR)) / price)
    //
    //  > MCR & < TCR |  only liquidatable in Recovery Mode (TCR < CCR)
    //                |  debt could be fully repaid by liquidator
    //                |  and up to (repaid debt * MCR) worth of collateral
    //                |  transferred to liquidator while the residue of collateral
    //                |  will be available in CollSurplusPool for owner to claim
    //                |  OR debt could be partially repaid by liquidator and
    //                |  liquidator could get collateral of (repaidDebt * max(LICR, min(ICR, MCR)) / price)
    // -----------------------------------------------------------------

    /// @notice Fully liquidate a single CDP by ID. CDP must meet the criteria for liquidation at the time of execution.
    /// @notice callable by anyone, attempts to liquidate the CdpId. Executes successfully if Cdp meets the conditions for liquidation (e.g. in Normal Mode, it liquidates if the Cdp's ICR < the system MCR).
    /// @dev forwards msg.data directly to the liquidation library using OZ proxy core delegation function
    /// @param _cdpId ID of the CDP to liquidate.

    function liquidate(bytes32 _cdpId) external override {
        _delegate(liquidationLibrary);
    }

    /// @notice Partially liquidate a single CDP.
    /// @dev forwards msg.data directly to the liquidation library using OZ proxy core delegation function
    /// @param _cdpId ID of the CDP to partially liquidate.
    /// @param _partialAmount Amount to partially liquidate.
    /// @param _upperPartialHint Upper hint for reinsertion of the CDP into the linked list.
    /// @param _lowerPartialHint Lower hint for reinsertion of the CDP into the linked list.
    function partiallyLiquidate(
        bytes32 _cdpId,
        uint256 _partialAmount,
        bytes32 _upperPartialHint,
        bytes32 _lowerPartialHint
    ) external override {
        _delegate(liquidationLibrary);
    }

    // --- Batch/Sequence liquidation functions ---

    /// @notice Attempt to liquidate a custom list of CDPs provided by the caller
    /// @notice Callable by anyone, accepts a custom list of Cdps addresses as an argument. Steps through the provided list and attempts to liquidate every Cdp, until it reaches the end or it runs out of gas. A Cdp is liquidated only if it meets the conditions for liquidation. For a batch of 10 Cdps, the gas costs per liquidated Cdp are roughly between 75K-83K, for a batch of 50 Cdps between 54K-69K.
    /// @dev forwards msg.data directly to the liquidation library using OZ proxy core delegation function
    /// @param _cdpArray Array of CDPs to liquidate.
    function batchLiquidateCdps(bytes32[] memory _cdpArray) external override {
        _delegate(liquidationLibrary);
    }

    // --- Redemption functions ---

    /// @notice // Redeem as much collateral as possible from given Cdp in exchange for EBTC up to specified maximum
    /// @param _redeemColFromCdp Struct containing variables for redeeming collateral.
    /// @return singleRedemption Struct containing redemption values.
    function _redeemCollateralFromCdp(
        SingleRedemptionInputs memory _redeemColFromCdp
    ) internal returns (SingleRedemptionValues memory singleRedemption) {
        // Determine the remaining amount (lot) to be redeemed,
        // capped by the entire debt of the Cdp minus the liquidation reserve
        singleRedemption.eBtcToRedeem = LiquityMath._min(
            _redeemColFromCdp.maxEBTCamount,
            Cdps[_redeemColFromCdp.cdpId].debt /// @audit Redeem everything
        );

        // Get the stEthToRecieve of equivalent value in USD
        singleRedemption.stEthToRecieve = collateral.getSharesByPooledEth(
            (singleRedemption.eBtcToRedeem * DECIMAL_PRECISION) / _redeemColFromCdp.price
        );

        // Repurposing this struct here to avoid stack too deep.
        CdpDebtAndCollShares memory _oldDebtAndColl = CdpDebtAndCollShares(
            Cdps[_redeemColFromCdp.cdpId].debt,
            Cdps[_redeemColFromCdp.cdpId].coll,
            0
        );

        // Decrease the debt and collateral of the current Cdp according to the EBTC lot and corresponding ETH to send
        uint256 newDebt = _oldDebtAndColl.entireDebt - singleRedemption.eBtcToRedeem;
        uint256 newColl = _oldDebtAndColl.entireColl - singleRedemption.stEthToRecieve; /// @audit This will revert

        if (newDebt == 0) {
            // No debt remains, close CDP
            // No debt left in the Cdp, therefore the cdp gets closed
            {
                address _borrower = sortedCdps.getOwnerAddress(_redeemColFromCdp.cdpId);
                uint256 _liquidatorRewardShares = Cdps[_redeemColFromCdp.cdpId]
                    .liquidatorRewardShares;

                singleRedemption.collSurplus = newColl; // Collateral surplus processed on full redemption
                singleRedemption.liquidatorRewardShares = _liquidatorRewardShares;
                singleRedemption.fullRedemption = true;

                _closeCdpByRedemption(
                    _redeemColFromCdp.cdpId,
                    0,
                    newColl,
                    _liquidatorRewardShares,
                    _borrower
                );

                emit CdpUpdated(
                    _redeemColFromCdp.cdpId,
                    _borrower,
                    _oldDebtAndColl.entireDebt,
                    _oldDebtAndColl.entireColl,
                    0,
                    0,
                    0,
                    CdpOperation.redeemCollateral
                );
            }
        } else {
            // Debt remains, reinsert CDP
            uint256 newNICR = LiquityMath._computeNominalCR(newColl, newDebt);

            /*
             * If the provided hint is out of date, we bail since trying to reinsert without a good hint will almost
             * certainly result in running out of gas.
             *
             * If the resultant net coll of the partial is less than the minimum, we bail.
             */
            if (
                newNICR != _redeemColFromCdp.partialRedemptionHintNICR ||
                collateral.getPooledEthByShares(newColl) < MIN_NET_COLL
            ) {
                singleRedemption.cancelledPartial = true;
                return singleRedemption;
            }

            sortedCdps.reInsert(
                _redeemColFromCdp.cdpId,
                newNICR,
                _redeemColFromCdp.upperPartialRedemptionHint,
                _redeemColFromCdp.lowerPartialRedemptionHint
            );

            Cdps[_redeemColFromCdp.cdpId].debt = newDebt;
            Cdps[_redeemColFromCdp.cdpId].coll = newColl;
            _updateStakeAndTotalStakes(_redeemColFromCdp.cdpId);

            address _borrower = ISortedCdps(sortedCdps).getOwnerAddress(_redeemColFromCdp.cdpId);
            emit CdpUpdated(
                _redeemColFromCdp.cdpId,
                _borrower,
                _oldDebtAndColl.entireDebt,
                _oldDebtAndColl.entireColl,
                newDebt,
                newColl,
                Cdps[_redeemColFromCdp.cdpId].stake,
                CdpOperation.redeemCollateral
            );
        }

        return singleRedemption;
    }

    /*
     * Called when a full redemption occurs, and closes the cdp.
     * The redeemer swaps (debt) EBTC for (debt)
     * worth of stETH, so the stETH liquidation reserve is all that remains.
     * In order to close the cdp, the stETH liquidation reserve is returned to the CDP owner,
     * The debt recorded on the cdp's struct is zero'd elswhere, in _closeCdp.
     * Any surplus stETH left in the cdp, is sent to the Coll surplus pool, and can be later claimed by the borrower.
     */
    function _closeCdpByRedemption(
        bytes32 _cdpId, // TODO: Remove?
        uint256 _EBTC,
        uint256 _collSurplus,
        uint256 _liquidatorRewardShares,
        address _borrower
    ) internal {
        _removeStake(_cdpId);
        _closeCdpWithoutRemovingSortedCdps(_cdpId, Status.closedByRedemption);

        // Update Active Pool EBTC, and send ETH to account
        activePool.decreaseSystemDebt(_EBTC);

        // Register stETH surplus from upcoming transfers of stETH collateral and liquidator reward shares
        collSurplusPool.increaseSurplusCollShares(_borrower, _collSurplus + _liquidatorRewardShares);

        // CEI: send stETH coll and liquidator reward shares from Active Pool to CollSurplus Pool
        activePool.transferSystemCollSharesAndLiquidatorReward(
            address(collSurplusPool),
            _collSurplus,
            _liquidatorRewardShares
        );
    }

    /// @notice Returns true if the CdpId specified is the lowest-ICR Cdp in the linked list that still has MCR > ICR
    /// @dev Returns false if the specified CdpId hint is blank
    /// @dev Returns false if the specified CdpId hint doesn't exist in the list
    /// @dev Returns false if the ICR of the specified CdpId is < MCR
    /// @dev Returns true if the specified CdpId is not blank, exists in the list, has an ICR > MCR, and the next lower Cdp in the list is either blank or has an ICR < MCR.
    function _isValidFirstRedemptionHint(
        bytes32 _firstRedemptionHint,
        uint256 _price
    ) internal view returns (bool) {
        if (
            _firstRedemptionHint == sortedCdps.nonExistId() ||
            !sortedCdps.contains(_firstRedemptionHint) ||
            getSyncedICR(_firstRedemptionHint, _price) < MCR
        ) {
            return false;
        }

        bytes32 nextCdp = sortedCdps.getNext(_firstRedemptionHint);
        return nextCdp == sortedCdps.nonExistId() || getSyncedICR(nextCdp, _price) < MCR;
    }

    /** 
    redeems `_EBTCamount` of eBTC for stETH from the system. Decreases the caller’s eBTC balance, and sends them the corresponding amount of stETH. Executes successfully if the caller has sufficient eBTC to redeem. The number of Cdps redeemed from is capped by `_maxIterations`. The borrower has to provide a `_maxFeePercentage` that he/she is willing to accept in case of a fee slippage, i.e. when another redemption transaction is processed first, driving up the redemption fee.
    */

    /* Send _EBTCamount EBTC to the system and redeem the corresponding amount of collateral
     * from as many Cdps as are needed to fill the redemption
     * request.  Applies pending rewards to a Cdp before reducing its debt and coll.
     *
     * Note that if _amount is very large, this function can run out of gas, specially if traversed cdps are small.
     * This can be easily avoided by
     * splitting the total _amount in appropriate chunks and calling the function multiple times.
     *
     * Param `_maxIterations` can also be provided, so the loop through Cdps is capped
     * (if it’s zero, it will be ignored).This makes it easier to
     * avoid OOG for the frontend, as only knowing approximately the average cost of an iteration is enough,
     * without needing to know the “topology”
     * of the cdp list. It also avoids the need to set the cap in stone in the contract,
     * nor doing gas calculations, as both gas price and opcode costs can vary.
     *
     * All Cdps that are redeemed from -- with the likely exception of the last one -- will end up with no debt left,
     * therefore they will be closed.
     * If the last Cdp does have some remaining debt, it has a finite ICR, and the reinsertion
     * could be anywhere in the list, therefore it requires a hint.
     * A frontend should use getRedemptionHints() to calculate what the ICR of this Cdp will be after redemption,
     * and pass a hint for its position
     * in the sortedCdps list along with the ICR value that the hint was found for.
     *
     * If another transaction modifies the list between calling getRedemptionHints()
     * and passing the hints to redeemCollateral(), it is very likely that the last (partially)
     * redeemed Cdp would end up with a different ICR than what the hint is for. In this case the
     * redemption will stop after the last completely redeemed Cdp and the sender will keep the
     * remaining EBTC amount, which they can attempt to redeem later.
     */
    function redeemCollateral(
        uint256 _EBTCamount,
        bytes32 _firstRedemptionHint,
        bytes32 _upperPartialRedemptionHint,
        bytes32 _lowerPartialRedemptionHint,
        uint256 _partialRedemptionHintNICR,
        uint256 _maxIterations,
        uint256 _maxFeePercentage
    ) external override nonReentrantSelfAndBOps {
        RedemptionTotals memory totals;

        _requireValidMaxFeePercentage(_maxFeePercentage);

        _syncGlobalAccounting(); // Apply state, we will syncGracePeriod at end of function

        totals.price = priceFeed.fetchPrice();
        {
            (
                uint256 tcrAtStart,
                uint256 totalCollSharesAtStart,
                uint256 totalEBTCSupplyAtStart
            ) = _getTCRWithSystemDebtAndCollShares(totals.price);
            totals.tcrAtStart = tcrAtStart;
            totals.totalCollSharesAtStart = totalCollSharesAtStart;
            totals.totalEBTCSupplyAtStart = totalEBTCSupplyAtStart;
        }

        _requireTCRoverMCR(totals.price, totals.tcrAtStart);
        _requireAmountGreaterThanZero(_EBTCamount);

        require(redemptionsPaused == false, "CdpManager: Redemptions Paused");

        _requireEBTCBalanceCoversRedemptionAndWithinSupply(
            ebtcToken,
            msg.sender,
            _EBTCamount,
            totals.totalEBTCSupplyAtStart
        );

        totals.remainingEBTC = _EBTCamount;
        address currentBorrower;
        bytes32 _cId = _firstRedemptionHint;

        if (_isValidFirstRedemptionHint(_firstRedemptionHint, totals.price)) {
            currentBorrower = sortedCdps.getOwnerAddress(_firstRedemptionHint);
        } else {
            _cId = sortedCdps.getLast();
            currentBorrower = sortedCdps.getOwnerAddress(_cId);
            // Find the first cdp with ICR >= MCR
            while (currentBorrower != address(0) && getSyncedICR(_cId, totals.price) < MCR) {
                _cId = sortedCdps.getPrev(_cId);
                currentBorrower = sortedCdps.getOwnerAddress(_cId);
            }
        }

        // Loop through the Cdps starting from the one with lowest collateral
        // ratio until _amount of EBTC is exchanged for collateral
        if (_maxIterations == 0) {
            _maxIterations = type(uint256).max;
        }

        bytes32 _firstRedeemed = _cId;
        bytes32 _lastRedeemed = _cId;
        uint256 _numCdpsFullyRedeemed;

        /**
            Core Redemption Loop
        */
        while (currentBorrower != address(0) && totals.remainingEBTC > 0 && _maxIterations > 0) {
            // Save the address of the Cdp preceding the current one, before potentially modifying the list
            {
                _syncAccounting(_cId); /// @audit This happens even if the re-insertion doesn't

                SingleRedemptionInputs memory _redeemColFromCdp = SingleRedemptionInputs(
                    _cId,
                    totals.remainingEBTC,
                    totals.price,
                    _upperPartialRedemptionHint,
                    _lowerPartialRedemptionHint,
                    _partialRedemptionHintNICR
                );
                SingleRedemptionValues memory singleRedemption = _redeemCollateralFromCdp(
                    _redeemColFromCdp
                );
                // Partial redemption was cancelled (out-of-date hint, or new net debt < minimum),
                // therefore we could not redeem from the last Cdp
                if (singleRedemption.cancelledPartial) break;

                totals.totalEBTCToRedeem = totals.totalEBTCToRedeem + singleRedemption.eBtcToRedeem;
                totals.totalETHDrawn = totals.totalETHDrawn + singleRedemption.stEthToRecieve;
                totals.remainingEBTC = totals.remainingEBTC - singleRedemption.eBtcToRedeem;
                totals.totalCollSharesSurplus =
                    totals.totalCollSharesSurplus +
                    singleRedemption.collSurplus;

                if (singleRedemption.fullRedemption) {
                    _lastRedeemed = _cId;
                    _numCdpsFullyRedeemed = _numCdpsFullyRedeemed + 1;
                }

                bytes32 _nextId = sortedCdps.getPrev(_cId);
                address nextUserToCheck = sortedCdps.getOwnerAddress(_nextId);
                currentBorrower = nextUserToCheck;
                _cId = _nextId;
            }
            _maxIterations--;
        }
        require(totals.totalETHDrawn > 0, "CdpManager: Unable to redeem any amount");

        // remove from sortedCdps
        if (_numCdpsFullyRedeemed == 1) {
            sortedCdps.remove(_firstRedeemed);
        } else if (_numCdpsFullyRedeemed > 1) {
            bytes32[] memory _toRemoveIds = _getCdpIdsToRemove(
                _lastRedeemed,
                _numCdpsFullyRedeemed,
                _firstRedeemed
            );
            sortedCdps.batchRemove(_toRemoveIds);
        }

        // Decay the baseRate due to time passed, and then increase it according to the size of this redemption.
        // Use the saved total EBTC supply value, from before it was reduced by the redemption.
        _updateBaseRateFromRedemption(
            totals.totalETHDrawn,
            totals.price,
            totals.totalEBTCSupplyAtStart
        );

        // Calculate the ETH fee
        totals.ETHFee = _getRedemptionFee(totals.totalETHDrawn);

        _requireUserAcceptsFee(totals.ETHFee, totals.totalETHDrawn, _maxFeePercentage);

        totals.ETHToSendToRedeemer = totals.totalETHDrawn - totals.ETHFee;

        _syncGracePeriodForGivenValues(
            totals.totalCollSharesAtStart - totals.totalETHDrawn - totals.totalCollSharesSurplus,
            totals.totalEBTCSupplyAtStart - totals.totalEBTCToRedeem,
            totals.price
        );

        emit Redemption(
            _EBTCamount,
            totals.totalEBTCToRedeem,
            totals.totalETHDrawn,
            totals.ETHFee,
            msg.sender
        );

        // Burn the total eBTC that is redeemed
        ebtcToken.burn(msg.sender, totals.totalEBTCToRedeem);

        // Update Active Pool eBTC debt internal accounting
        activePool.decreaseSystemDebt(totals.totalEBTCToRedeem);

        // Allocate the stETH fee to the FeeRecipient
        activePool.allocateSystemCollSharesToFeeRecipient(totals.ETHFee);

        // CEI: Send the stETH drawn to the redeemer
        activePool.transferSystemCollShares(msg.sender, totals.ETHToSendToRedeemer);
    }

    // --- Helper functions ---

    function _getCdpIdsToRemove(
        bytes32 _start,
        uint256 _total,
        bytes32 _end
    ) internal view returns (bytes32[] memory) {
        uint256 _cnt = _total;
        bytes32 _id = _start;
        bytes32[] memory _toRemoveIds = new bytes32[](_total);
        while (_cnt > 0 && _id != bytes32(0)) {
            _toRemoveIds[_total - _cnt] = _id;
            _cnt = _cnt - 1;
            _id = sortedCdps.getNext(_id);
        }
        require(_toRemoveIds[0] == _start, "CdpManager: batchRemoveSortedCdpIds check start error");
        require(
            _toRemoveIds[_total - 1] == _end,
            "CdpManager: batchRemoveSortedCdpIds check end error"
        );
        return _toRemoveIds;
    }

    function syncAccounting(bytes32 _cdpId) external override {
        // _requireCallerIsBorrowerOperations(); /// @audit Please check this and let us know if opening this creates issues | TODO: See Stermi Partial Liq
        return _syncAccounting(_cdpId);
    }

    function removeStake(bytes32 _cdpId) external override {
        _requireCallerIsBorrowerOperations();
        return _removeStake(_cdpId);
    }

    // get totalStakes after split fee taken removed
    function getTotalStakeForFeeTaken(
        uint256 _feeTaken
    ) public view override returns (uint256, uint256) {
        uint256 stake = _computeNewStake(_feeTaken);
        uint256 _newTotalStakes = totalStakes - stake;
        return (_newTotalStakes, stake);
    }

    function updateStakeAndTotalStakes(bytes32 _cdpId) external override returns (uint256) {
        _requireCallerIsBorrowerOperations();
        return _updateStakeAndTotalStakes(_cdpId);
    }

    function closeCdp(
        bytes32 _cdpId,
        address _borrower,
        uint256 _debt,
        uint256 _coll
    ) external override {
        _requireCallerIsBorrowerOperations();
        emit CdpUpdated(_cdpId, _borrower, _debt, _coll, 0, 0, 0, CdpOperation.closeCdp);
        return _closeCdp(_cdpId, Status.closedByOwner);
    }

    // Push the owner's address to the Cdp owners list, and record the corresponding array index on the Cdp struct
    function _addCdpIdToArray(bytes32 _cdpId) internal returns (uint128 index) {
        /* Max array size is 2**128 - 1, i.e. ~3e30 cdps. No risk of overflow, since cdps have minimum EBTC
        debt of liquidation reserve plus MIN_NET_DEBT.
        3e30 EBTC dwarfs the value of all wealth in the world ( which is < 1e15 USD). */

        // Push the Cdpowner to the array
        CdpIds.push(_cdpId);

        // Record the index of the new Cdpowner on their Cdp struct
        index = uint128(CdpIds.length - 1);
        Cdps[_cdpId].arrayIndex = index;

        return index;
    }

    // --- Recovery Mode and TCR functions ---

    /**
    Returns the systemic entire debt assigned to Cdps, i.e. the systemDebt value of the Active Pool.
     */
    function getSystemDebt() public view returns (uint256 entireSystemDebt) {
        return _getSystemDebt();
    }

    /**
    returns the total collateralization ratio (TCR) of the system.  The TCR is based on the the entire system debt and collateral (including pending rewards). */
    function getTCR(uint256 _price) external view override returns (uint256) {
        return _getTCR(_price);
    }

    /**
    reveals whether or not the system is in Recovery Mode (i.e. whether the Total Collateralization Ratio (TCR) is below the Critical Collateralization Ratio (CCR)).
    */
    function checkRecoveryMode(uint256 _price) external view override returns (bool) {
        return _checkRecoveryMode(_price);
    }

    // Check whether or not the system *would be* in Recovery Mode,
    // given an ETH:USD price, and the entire system coll and debt.
    function _checkPotentialRecoveryMode(
        uint256 _systemCollShares,
        uint256 _systemDebt,
        uint256 _price
    ) internal view returns (bool) {
        uint256 TCR = _computeTCRWithGivenSystemValues(_systemCollShares, _systemDebt, _price);
        return TCR < CCR;
    }

    // --- Redemption fee functions ---

    /*
     * This function has two impacts on the baseRate state variable:
     * 1) decays the baseRate based on time passed since last redemption or EBTC borrowing operation.
     * then,
     * 2) increases the baseRate based on the amount redeemed, as a proportion of total supply
     */
    function _updateBaseRateFromRedemption(
        uint256 _ETHDrawn,
        uint256 _price,
        uint256 _totalEBTCSupply
    ) internal returns (uint256) {
        uint256 decayedBaseRate = _calcDecayedBaseRate();

        /* Convert the drawn ETH back to EBTC at face value rate (1 EBTC:1 USD), in order to get
         * the fraction of total supply that was redeemed at face value. */
        uint256 redeemedEBTCFraction = (collateral.getPooledEthByShares(_ETHDrawn) * _price) /
            _totalEBTCSupply;

        uint256 newBaseRate = decayedBaseRate + (redeemedEBTCFraction / beta);
        newBaseRate = LiquityMath._min(newBaseRate, DECIMAL_PRECISION); // cap baseRate at a maximum of 100%
        require(newBaseRate > 0, "CdpManager: new baseRate is zero!"); // Base rate is always non-zero after redemption

        // Update the baseRate state variable
        baseRate = newBaseRate;
        emit BaseRateUpdated(newBaseRate);

        _updateLastRedemptionTimestamp();

        return newBaseRate;
    }

    function getRedemptionRate() public view override returns (uint256) {
        return _calcRedemptionRate(baseRate);
    }

    function getRedemptionRateWithDecay() public view override returns (uint256) {
        return _calcRedemptionRate(_calcDecayedBaseRate());
    }

    function _calcRedemptionRate(uint256 _baseRate) internal view returns (uint256) {
        return
            LiquityMath._min(
                redemptionFeeFloor + _baseRate,
                DECIMAL_PRECISION // cap at a maximum of 100%
            );
    }

    function _getRedemptionFee(uint256 _ETHDrawn) internal view returns (uint256) {
        return _calcRedemptionFee(getRedemptionRate(), _ETHDrawn);
    }

    function getRedemptionFeeWithDecay(uint256 _ETHDrawn) external view override returns (uint256) {
        return _calcRedemptionFee(getRedemptionRateWithDecay(), _ETHDrawn);
    }

    function _calcRedemptionFee(
        uint256 _redemptionRate,
        uint256 _ETHDrawn
    ) internal pure returns (uint256) {
        uint256 redemptionFee = (_redemptionRate * _ETHDrawn) / DECIMAL_PRECISION;
        require(redemptionFee < _ETHDrawn, "CdpManager: Fee would eat up all returned collateral");
        return redemptionFee;
    }

    // Updates the baseRate state variable based on time elapsed since the last redemption or EBTC borrowing operation.
    function decayBaseRateFromBorrowing() external override {
        _requireCallerIsBorrowerOperations();

        _decayBaseRate();
    }

    function _decayBaseRate() internal {
        uint256 decayedBaseRate = _calcDecayedBaseRate();
        require(decayedBaseRate <= DECIMAL_PRECISION, "CdpManager: baseRate too large!"); // The baseRate can decay to 0

        baseRate = decayedBaseRate;
        emit BaseRateUpdated(decayedBaseRate);

        _updateLastRedemptionTimestamp();
    }

    // --- Internal fee functions ---

    // Update the last fee operation time only if time passed >= decay interval. This prevents base rate griefing.
    function _updateLastRedemptionTimestamp() internal {
        uint256 timePassed = block.timestamp > lastRedemptionTimestamp
            ? block.timestamp - lastRedemptionTimestamp
            : 0;

        if (timePassed >= SECONDS_IN_ONE_MINUTE) {
            // Using the effective elapsed time that is consumed so far to update lastRedemptionTimestamp
            // instead block.timestamp for consistency with _calcDecayedBaseRate()
            lastRedemptionTimestamp += _minutesPassedSinceLastRedemption() * SECONDS_IN_ONE_MINUTE;
            emit LastRedemptionTimestampUpdated(block.timestamp);
        }
    }

    function _calcDecayedBaseRate() internal view returns (uint256) {
        uint256 minutesPassed = _minutesPassedSinceLastRedemption();
        uint256 decayFactor = LiquityMath._decPow(minuteDecayFactor, minutesPassed);

        return (baseRate * decayFactor) / DECIMAL_PRECISION;
    }

    function _minutesPassedSinceLastRedemption() internal view returns (uint256) {
        return
            block.timestamp > lastRedemptionTimestamp
                ? ((block.timestamp - lastRedemptionTimestamp) / SECONDS_IN_ONE_MINUTE)
                : 0;
    }

    function getDeploymentStartTime() public view returns (uint256) {
        return deploymentStartTime;
    }

    // Check whether or not the system *would be* in Recovery Mode,
    // given an ETH:USD price, and the entire system coll and debt.
    function checkPotentialRecoveryMode(
        uint256 _systemCollShares,
        uint256 _systemDebt,
        uint256 _price
    ) external view returns (bool) {
        return _checkPotentialRecoveryMode(_systemCollShares, _systemDebt, _price);
    }

    // --- 'require' wrapper functions ---

    function _requireEBTCBalanceCoversRedemptionAndWithinSupply(
        IEBTCToken _ebtcToken,
        address _redeemer,
        uint256 _amount,
        uint256 _totalSupply
    ) internal view {
        uint256 callerBalance = _ebtcToken.balanceOf(_redeemer);
        require(
            callerBalance >= _amount,
            "CdpManager: Requested redemption amount must be <= user's EBTC token balance"
        );
        require(
            callerBalance <= _totalSupply,
            "CdpManager: redeemer's EBTC balance exceeds total supply!"
        );
    }

    function _requireAmountGreaterThanZero(uint256 _amount) internal pure {
        require(_amount > 0, "CdpManager: Amount must be greater than zero");
    }

    function _requireTCRoverMCR(uint256 _price, uint256 _TCR) internal view {
        require(_TCR >= MCR, "CdpManager: Cannot redeem when TCR < MCR");
    }

    function _requireValidMaxFeePercentage(uint256 _maxFeePercentage) internal view {
        require(
            _maxFeePercentage >= redemptionFeeFloor && _maxFeePercentage <= DECIMAL_PRECISION,
            "Max fee percentage must be between redemption fee floor and 100%"
        );
    }

    // --- Governance Parameters ---

    function setStakingRewardSplit(uint256 _stakingRewardSplit) external requiresAuth {
        require(
            _stakingRewardSplit <= MAX_REWARD_SPLIT,
            "CDPManager: new staking reward split exceeds max"
        );

        syncGlobalAccountingAndGracePeriod();

        stakingRewardSplit = _stakingRewardSplit;
        emit StakingRewardSplitSet(_stakingRewardSplit);
    }

    function setRedemptionFeeFloor(uint256 _redemptionFeeFloor) external requiresAuth {
        require(
            _redemptionFeeFloor >= MIN_REDEMPTION_FEE_FLOOR,
            "CDPManager: new redemption fee floor is lower than minimum"
        );
        require(
            _redemptionFeeFloor <= DECIMAL_PRECISION,
            "CDPManager: new redemption fee floor is higher than maximum"
        );

        syncGlobalAccountingAndGracePeriod();

        redemptionFeeFloor = _redemptionFeeFloor;
        emit RedemptionFeeFloorSet(_redemptionFeeFloor);
    }

    function setMinuteDecayFactor(uint256 _minuteDecayFactor) external requiresAuth {
        require(
            _minuteDecayFactor >= MIN_MINUTE_DECAY_FACTOR,
            "CDPManager: new minute decay factor out of range"
        );
        require(
            _minuteDecayFactor <= MAX_MINUTE_DECAY_FACTOR,
            "CDPManager: new minute decay factor out of range"
        );

        syncGlobalAccountingAndGracePeriod();

        // decay first according to previous factor
        _decayBaseRate();

        // set new factor after decaying
        minuteDecayFactor = _minuteDecayFactor;
        emit MinuteDecayFactorSet(_minuteDecayFactor);
    }

    function setBeta(uint256 _beta) external requiresAuth {
        syncGlobalAccountingAndGracePeriod();

        _decayBaseRate();

        beta = _beta;
        emit BetaSet(_beta);
    }

    function setRedemptionsPaused(bool _paused) external requiresAuth {
        syncGlobalAccountingAndGracePeriod();
        _decayBaseRate();

        redemptionsPaused = _paused;
        emit RedemptionsPaused(_paused);
    }

    // --- Cdp property getters ---

    /// @notice Get status of a CDP. Named values can be found in ICdpManagerData.Status.
    function getCdpStatus(bytes32 _cdpId) external view override returns (uint256) {
        return uint256(Cdps[_cdpId].status);
    }

    /// @notice Get stake value of a CDP.
    function getCdpStake(bytes32 _cdpId) external view override returns (uint256) {
        return Cdps[_cdpId].stake;
    }

    /// @notice Get stored debt value of a CDP, in eBTC units. Does not include pending changes from redistributions
    function getCdpDebt(bytes32 _cdpId) external view override returns (uint256) {
        return Cdps[_cdpId].debt;
    }

    /// @notice Get stored collateral value of a CDP, in stETH shares. Does not include pending changes from redistributions or unprocessed staking yield.
    function getCdpCollShares(bytes32 _cdpId) external view override returns (uint256) {
        return Cdps[_cdpId].coll;
    }

    /**
        @notice Get shares value of the liquidator gas incentive reward stored for a CDP. 
        @notice This value is processed when a CDP closes. 
        @dev This value is returned to the borrower when they close their own CDP
        @dev This value is given to liquidators upon fully liquidating a CDP
        @dev This value is sent to the CollSurplusPool for reclaiming by the borrower when their CDP is redeemed
    */
    function getCdpLiquidatorRewardShares(bytes32 _cdpId) external view override returns (uint256) {
        return Cdps[_cdpId].liquidatorRewardShares;
    }

    // --- Cdp property setters, called by BorrowerOperations ---

    /**
        @notice Initiailze all state for new CDP
        @dev Only callable by BorrowerOperations, critical trust assumption 
        @dev Requires CDP to be already inserted into linked list correctly
        @param _cdpId id of CDP to initialize state for. Inserting the blank CDP into the linked list grants this ID
        @param _debt debt units of CDP
        @param _coll collateral shares of CDP
        @param _liquidatorRewardShares collateral shares for CDP gas stipend
        @param _borrower borrower address
     */
    function initializeCdp(
        bytes32 _cdpId,
        uint256 _debt,
        uint256 _coll,
        uint256 _liquidatorRewardShares,
        address _borrower
    ) external {
        _requireCallerIsBorrowerOperations();

        Cdps[_cdpId].debt = _debt;
        Cdps[_cdpId].coll = _coll;
        Cdps[_cdpId].status = Status.active;
        Cdps[_cdpId].liquidatorRewardShares = _liquidatorRewardShares;

        _applyAccumulatedFeeSplit(_cdpId);
        _updateRedistributedDebtSnapshot(_cdpId);
        uint256 stake = _updateStakeAndTotalStakes(_cdpId);
        uint256 index = _addCdpIdToArray(_cdpId);

        // Previous debt and coll are by definition zero upon opening a new CDP
        emit CdpUpdated(_cdpId, _borrower, 0, 0, _debt, _coll, stake, CdpOperation.openCdp);
    }

    /**
        @notice Set new CDP debt and collateral values, updating stake accordingly.
        @dev Only callable by BorrowerOperations, critical trust assumption 
        @param _cdpId Id of CDP to update state for
        @param _borrower borrower of CDP. Passed along in function to avoid an extra storage read.
        @param _coll collateral shares of CDP before update operation. Passed in function to avoid an extra stroage read.
        @param _debt debt units of CDP before update operation. Passed in function to avoid an extra stroage read.
        @param _newColl collateral shares of CDP after update operation.
        @param _newDebt debt units of CDP after update operation.
     */
    function updateCdp(
        bytes32 _cdpId,
        address _borrower,
        uint256 _coll,
        uint256 _debt,
        uint256 _newColl,
        uint256 _newDebt
    ) external {
        _requireCallerIsBorrowerOperations();

        _setCdpCollShares(_cdpId, _newColl);
        _setCdpDebt(_cdpId, _newDebt);

        uint256 stake = _updateStakeAndTotalStakes(_cdpId);

        emit CdpUpdated(
            _cdpId,
            _borrower,
            _debt,
            _coll,
            _newDebt,
            _newColl,
            stake,
            CdpOperation.adjustCdp
        );
    }

    /**
     * @notice Set the collateral of a CDP
     * @param _cdpId The ID of the CDP
     * @param _newColl New collateral value, in stETH shares
     */
    function _setCdpCollShares(bytes32 _cdpId, uint256 _newColl) internal {
        Cdps[_cdpId].coll = _newColl;
    }

    /**
     * @notice Set the debt of a CDP
     * @param _cdpId The ID of the CDP
     * @param _newDebt New debt units value
     */
    function _setCdpDebt(bytes32 _cdpId, uint256 _newDebt) internal {
        Cdps[_cdpId].debt = _newDebt;
    }
}


Lines covered:	297 / 322 (92.2%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./Interfaces/ICdpManager.sol";
import "./Interfaces/ICollSurplusPool.sol";
import "./Interfaces/IEBTCToken.sol";
import "./Interfaces/ISortedCdps.sol";
import "./Dependencies/LiquityBase.sol";
import "./Dependencies/ReentrancyGuard.sol";
import "./Dependencies/ICollateralTokenOracle.sol";
import "./Dependencies/AuthNoOwner.sol";

/**
    @notice CDP Manager storage and shared functions
    @dev CDP Manager was split to get around contract size limitations, liquidation related functions are delegated to LiquidationLibrary contract code.
    @dev Both must maintain the same storage layout, so shared storage components where placed here
    @dev Shared functions were also added here to de-dup code
 */
contract CdpManagerStorage is LiquityBase, ReentrancyGuard, ICdpManagerData, AuthNoOwner {
    // TODO: IMPROVE
    // NOTE: No packing cause it's the last var, no need for u64
    uint128 public constant UNSET_TIMESTAMP = type(uint128).max;
    uint128 public constant MINIMUM_GRACE_PERIOD = 15 minutes;

    // TODO: IMPROVE THIS!!!
    uint128 public lastGracePeriodStartTimestamp = UNSET_TIMESTAMP; // use max to signify
    uint128 public recoveryModeGracePeriod = MINIMUM_GRACE_PERIOD;

    // TODO: Pitfal is fee split // NOTE: Solved by calling `syncGracePeriod` on external operations from BO

    /// @notice Start the recovery mode grace period, if the system is in RM and the grace period timestamp has not already been set
    /// @dev Trusted function to allow BorrowerOperations actions to set RM Grace Period
    /// @dev Assumes BorrowerOperations has correctly calculated and passed in the new system TCR
    /// @dev To maintain CEI compliance we use this trusted function
    function notifyStartGracePeriod(uint256 tcr) external {
        _requireCallerIsBorrowerOperations();
        _startGracePeriod(tcr);
    }

    /// @notice End the recovery mode grace period, if the system is no longer in RM
    /// @dev Trusted function to allow BorrowerOperations actions to set RM Grace Period
    /// @dev Assumes BorrowerOperations has correctly calculated and passed in the new system TCR
    /// @dev To maintain CEI compliance we use this trusted function
    function notifyEndGracePeriod(uint256 tcr) external {
        _requireCallerIsBorrowerOperations();
        _endGracePeriod(tcr);
    }

    /// @dev Internal notify called by Redemptions and Liquidations
    /// @dev Specified TCR is emitted for notification pruposes regardless of whether the Grace Period timestamp is set
    function _startGracePeriod(uint256 _tcr) internal {
        emit TCRNotified(_tcr);

        if (lastGracePeriodStartTimestamp == UNSET_TIMESTAMP) {
            lastGracePeriodStartTimestamp = uint128(block.timestamp);

            emit GracePeriodStart();
        }
    }

    /// @notice Clear RM Grace Period timestamp if it has been set
    /// @notice No input validation, calling function must confirm that the system is not in recovery mode to be valid
    /// @dev Specified TCR is emitted for notification pruposes regardless of whether the Grace Period timestamp is set
    /// @dev Internal notify called by Redemptions and Liquidations
    function _endGracePeriod(uint256 _tcr) internal {
        emit TCRNotified(_tcr);

        if (lastGracePeriodStartTimestamp != UNSET_TIMESTAMP) {
            lastGracePeriodStartTimestamp = UNSET_TIMESTAMP;

            emit GracePeriodEnd();
        }
    }

    function _syncGracePeriod() internal {
        uint256 price = priceFeed.fetchPrice();
        uint256 tcr = _getTCR(price);
        bool isRecoveryMode = _checkRecoveryModeForTCR(tcr);

        if (isRecoveryMode) {
            _startGracePeriod(tcr);
        } else {
            _endGracePeriod(tcr);
        }
    }

    /// @dev Set RM grace period based on specified system collShares, system debt, and price
    /// @dev Variant for internal use in redemptions and liquidations
    function _syncGracePeriodForGivenValues(
        uint256 systemCollShares,
        uint256 systemDebt,
        uint256 price
    ) internal {
        // Compute TCR with specified values
        uint256 newTCR = LiquityMath._computeCR(
            collateral.getPooledEthByShares(systemCollShares),
            systemDebt,
            price
        );

        if (newTCR < CCR) {
            // Notify system is in RM
            _startGracePeriod(newTCR);
        } else {
            // Notify system is outside RM
            _endGracePeriod(newTCR);
        }
    }

    /// @notice Set grace period duratin
    /// @notice Permissioned governance function, must set grace period duration above hardcoded minimum
    /// @param _gracePeriod new grace period duration, in seconds
    function setGracePeriod(uint128 _gracePeriod) external requiresAuth {
        require(
            _gracePeriod >= MINIMUM_GRACE_PERIOD,
            "CdpManager: Grace period below minimum duration"
        );

        syncGlobalAccountingAndGracePeriod();
        recoveryModeGracePeriod = _gracePeriod;
        emit GracePeriodSet(_gracePeriod);
    }

    string public constant NAME = "CdpManager";

    // --- Connected contract declarations ---

    address public immutable borrowerOperationsAddress;

    ICollSurplusPool immutable collSurplusPool;

    IEBTCToken public immutable override ebtcToken;

    address public immutable liquidationLibrary;

    // A doubly linked list of Cdps, sorted by their sorted by their collateral ratios
    ISortedCdps public immutable sortedCdps;

    // --- Data structures ---

    uint256 public constant SECONDS_IN_ONE_MINUTE = 60;

    uint256 public constant MIN_REDEMPTION_FEE_FLOOR = (DECIMAL_PRECISION * 5) / 1000; // 0.5%
    uint256 public redemptionFeeFloor = MIN_REDEMPTION_FEE_FLOOR;
    bool public redemptionsPaused;
    /*
     * Half-life of 12h. 12h = 720 min
     * (1/2) = d^720 => d = (1/2)^(1/720)
     */
    uint256 public minuteDecayFactor = 999037758833783000;
    uint256 public constant MIN_MINUTE_DECAY_FACTOR = 1; // Non-zero
    uint256 public constant MAX_MINUTE_DECAY_FACTOR = 999999999999999999; // Corresponds to a very fast decay rate, but not too extreme

    uint256 internal immutable deploymentStartTime;

    /*
     * BETA: 18 digit decimal. Parameter by which to divide the redeemed fraction,
     * in order to calc the new base rate from a redemption.
     * Corresponds to (1 / ALPHA) in the white paper.
     */
    uint256 public beta = 2;

    uint256 public baseRate;

    uint256 public stakingRewardSplit;

    // The timestamp of the latest fee operation (redemption or new EBTC issuance)
    uint256 public lastRedemptionTimestamp;

    mapping(bytes32 => Cdp) public Cdps;

    uint256 public override totalStakes;

    // Snapshot of the value of totalStakes, taken immediately after the latest liquidation and split fee claim
    uint256 public totalStakesSnapshot;

    // Snapshot of the total collateral across the ActivePool, immediately after the latest liquidation and split fee claim
    uint256 public totalCollateralSnapshot;

    /*
     * systemDebtRedistributionIndex track the sums of accumulated liquidation rewards per unit staked.
     * During its lifetime, each stake earns:
     *
     * A systemDebt increase  of ( stake * [systemDebtRedistributionIndex - systemDebtRedistributionIndex(0)] )
     *
     * Where systemDebtRedistributionIndex(0) are snapshots of systemDebtRedistributionIndex
     * for the active Cdp taken at the instant the stake was made
     */
    uint256 public systemDebtRedistributionIndex;

    /* Global Index for (Full Price Per Share) of underlying collateral token */
    uint256 public override stEthIndex;
    /* Global Fee accumulator (never decreasing) per stake unit in CDPManager, similar to systemDebtRedistributionIndex */
    uint256 public override systemStEthFeePerUnitIndex;
    /* Global Fee accumulator calculation error due to integer division, similar to redistribution calculation */
    uint256 public override systemStEthFeePerUnitIndexError;
    /* Individual CDP Fee accumulator tracker, used to calculate fee split distribution */
    mapping(bytes32 => uint256) public stEthFeePerUnitIndex;
    /* Update timestamp for global index */
    uint256 lastIndexTimestamp;
    // Map active cdps to their RewardSnapshot (eBTC debt redistributed)
    mapping(bytes32 => uint256) public debtRedistributionIndex;

    // Array of all active cdp Ids - used to to compute an approximate hint off-chain, for the sorted list insertion
    bytes32[] public CdpIds;

    // Error trackers for the cdp redistribution calculation
    uint256 public lastETHError_Redistribution;
    uint256 public lastEBTCDebtErrorRedistribution;

    constructor(
        address _liquidationLibraryAddress,
        address _authorityAddress,
        address _borrowerOperationsAddress,
        address _collSurplusPool,
        address _ebtcToken,
        address _sortedCdps,
        address _activePool,
        address _priceFeed,
        address _collateral
    ) LiquityBase(_activePool, _priceFeed, _collateral) {
        // TODO: Move to setAddresses or _tickInterest?
        deploymentStartTime = block.timestamp;
        liquidationLibrary = _liquidationLibraryAddress;

        _initializeAuthority(_authorityAddress);

        borrowerOperationsAddress = _borrowerOperationsAddress;
        collSurplusPool = ICollSurplusPool(_collSurplusPool);
        ebtcToken = IEBTCToken(_ebtcToken);
        sortedCdps = ISortedCdps(_sortedCdps);
    }

    /**
        @notice BorrowerOperations and CdpManager share reentrancy status by confirming the other's locked flag before beginning operation
        @dev This is an alternative to the more heavyweight solution of both being able to set the reentrancy flag on a 3rd contract.
     */
    modifier nonReentrantSelfAndBOps() {
        require(locked == OPEN, "CdpManager: Reentrancy in nonReentrant call");
        require(
            ReentrancyGuard(borrowerOperationsAddress).locked() == OPEN,
            "BorrowerOperations: Reentrancy in nonReentrant call"
        );

        locked = LOCKED;

        _;

        locked = OPEN;
    }

    function _closeCdp(bytes32 _cdpId, Status closedStatus) internal {
        _closeCdpWithoutRemovingSortedCdps(_cdpId, closedStatus);
        sortedCdps.remove(_cdpId);
    }

    function _closeCdpWithoutRemovingSortedCdps(bytes32 _cdpId, Status closedStatus) internal {
        require(
            closedStatus != Status.nonExistent && closedStatus != Status.active,
            "CdpManagerStorage: close non-exist or non-active CDP!"
        );

        uint256 CdpIdsArrayLength = CdpIds.length;
        _requireMoreThanOneCdpInSystem(CdpIdsArrayLength);

        Cdps[_cdpId].status = closedStatus;
        Cdps[_cdpId].coll = 0;
        Cdps[_cdpId].debt = 0;
        Cdps[_cdpId].liquidatorRewardShares = 0;

        debtRedistributionIndex[_cdpId] = 0;
        stEthFeePerUnitIndex[_cdpId] = 0;

        _removeCdp(_cdpId, CdpIdsArrayLength);
    }

    /*
     * Updates snapshots of system total stakes and total collateral,
     * excluding a given collateral remainder from the calculation.
     * Used in a liquidation sequence.
     *
     * The calculation excludes a portion of collateral that is in the ActivePool:
     *
     * the total ETH gas compensation from the liquidation sequence
     *
     * The ETH as compensation must be excluded as it is always sent out at the very end of the liquidation sequence.
     */
    function _updateSystemSnapshotsExcludeCollRemainder(uint256 _collRemainder) internal {
        uint256 _totalStakesSnapshot = totalStakes;
        totalStakesSnapshot = _totalStakesSnapshot;

        uint256 _totalCollateralSnapshot = activePool.getSystemCollShares() - _collRemainder;
        totalCollateralSnapshot = _totalCollateralSnapshot;

        emit SystemSnapshotsUpdated(_totalStakesSnapshot, _totalCollateralSnapshot);
    }

    /**
    get the pending Cdp debt "reward" (i.e. the amount of extra debt assigned to the Cdp) from liquidation redistribution events, earned by their stake
    */
    function _getPendingRedistributedDebt(
        bytes32 _cdpId
    ) internal view returns (uint256 pendingEBTCDebtReward) {
        Cdp storage cdp = Cdps[_cdpId];

        if (cdp.status != Status.active) {
            return 0;
        }

        uint256 rewardPerUnitStaked = systemDebtRedistributionIndex -
            debtRedistributionIndex[_cdpId];

        if (rewardPerUnitStaked > 0) {
            pendingEBTCDebtReward = (cdp.stake * rewardPerUnitStaked) / DECIMAL_PRECISION;
        }
    }

    function _hasRedistributedDebt(bytes32 _cdpId) internal view returns (bool) {
        /*
         * A Cdp has pending rewards if its snapshot is less than the current rewards per-unit-staked sum:
         * this indicates that rewards have occured since the snapshot was made, and the user therefore has
         * pending rewards
         */
        if (Cdps[_cdpId].status != Status.active) {
            return false;
        }

        // Returns true if there have been any redemptions
        return (debtRedistributionIndex[_cdpId] < systemDebtRedistributionIndex);
    }

    function _updateRedistributedDebtSnapshot(bytes32 _cdpId) internal {
        uint256 _L_EBTCDebt = systemDebtRedistributionIndex;

        debtRedistributionIndex[_cdpId] = _L_EBTCDebt;
        emit CdpDebtRedistributionIndexUpdated(_cdpId, _L_EBTCDebt);
    }

    // Add the borrowers's coll and debt rewards earned from redistributions, to their Cdp
    function _syncAccounting(bytes32 _cdpId) internal {
        (, uint _newDebt, , uint _pendingDebt) = _applyAccumulatedFeeSplit(_cdpId);

        // Update pending debts
        if (_pendingDebt > 0) {
            Cdp storage _cdp = Cdps[_cdpId];
            uint256 prevDebt = _cdp.debt;
            uint256 prevColl = _cdp.coll;

            // Apply pending rewards to cdp's state
            _cdp.debt = _newDebt;

            _updateRedistributedDebtSnapshot(_cdpId);

            emit CdpUpdated(
                _cdpId,
                ISortedCdps(sortedCdps).getOwnerAddress(_cdpId),
                prevDebt,
                prevColl,
                _newDebt,
                prevColl,
                Cdps[_cdpId].stake,
                CdpOperation.syncAccounting
            );
        }
    }

    // Remove borrower's stake from the totalStakes sum, and set their stake to 0
    function _removeStake(bytes32 _cdpId) internal {
        uint256 _newTotalStakes = totalStakes - Cdps[_cdpId].stake;
        totalStakes = _newTotalStakes;
        Cdps[_cdpId].stake = 0;
        emit TotalStakesUpdated(_newTotalStakes);
    }

    // Update borrower's stake based on their latest collateral value
    // and update totalStakes accordingly as well
    function _updateStakeAndTotalStakes(bytes32 _cdpId) internal returns (uint256) {
        (uint256 newStake, uint256 oldStake) = _updateStakeForCdp(_cdpId);

        uint256 _newTotalStakes = totalStakes + newStake - oldStake;
        totalStakes = _newTotalStakes;

        emit TotalStakesUpdated(_newTotalStakes);

        return newStake;
    }

    // Update borrower's stake based on their latest collateral value
    function _updateStakeForCdp(bytes32 _cdpId) internal returns (uint256, uint256) {
        Cdp storage _cdp = Cdps[_cdpId];
        uint256 newStake = _computeNewStake(_cdp.coll);
        uint256 oldStake = _cdp.stake;
        _cdp.stake = newStake;

        return (newStake, oldStake);
    }

    // Calculate a new stake based on the snapshots of the totalStakes and totalCollateral taken at the last liquidation
    function _computeNewStake(uint256 _coll) internal view returns (uint256) {
        uint256 stake;
        if (totalCollateralSnapshot == 0) {
            stake = _coll;
        } else {
            /*
             * The following check holds true because:
             * - The system always contains >= 1 cdp
             * - When we close or liquidate a cdp, we redistribute the pending rewards,
             * so if all cdps were closed/liquidated,
             * rewards would’ve been emptied and totalCollateralSnapshot would be zero too.
             */
            require(totalStakesSnapshot > 0, "CdpManagerStorage: zero totalStakesSnapshot!");
            stake = (_coll * totalStakesSnapshot) / totalCollateralSnapshot;
        }
        return stake;
    }

    /*
     * Remove a Cdp owner from the CdpOwners array, not preserving array order. Removing owner 'B' does the following:
     * [A B C D E] => [A E C D], and updates E's Cdp struct to point to its new array index.
     */
    function _removeCdp(bytes32 _cdpId, uint256 CdpIdsArrayLength) internal {
        Status cdpStatus = Cdps[_cdpId].status;
        // It’s set in caller function `_closeCdp`
        require(
            cdpStatus != Status.nonExistent && cdpStatus != Status.active,
            "CdpManagerStorage: remove non-exist or non-active CDP!"
        );

        uint128 index = Cdps[_cdpId].arrayIndex;
        uint256 length = CdpIdsArrayLength;
        uint256 idxLast = length - 1;

        require(index <= idxLast, "CdpManagerStorage: CDP indexing overflow!");

        bytes32 idToMove = CdpIds[idxLast];

        CdpIds[index] = idToMove;
        Cdps[idToMove].arrayIndex = index;
        emit CdpArrayIndexUpdated(idToMove, index);

        CdpIds.pop();
    }

    // --- Recovery Mode and TCR functions ---

    // Calculate TCR given an price, and the entire system coll and debt.
    function _computeTCRWithGivenSystemValues(
        uint256 _systemCollShares,
        uint256 _systemDebt,
        uint256 _price
    ) internal view returns (uint256) {
        uint256 _totalColl = collateral.getPooledEthByShares(_systemCollShares);
        return LiquityMath._computeCR(_totalColl, _systemDebt, _price);
    }

    // --- Staking-Reward Fee split functions ---

    // Claim split fee if there is staking-reward coming
    // and update global index & fee-per-unit variables
    /// @dev BO can call this without trigggering a
    function syncGlobalAccounting() external {
        _requireCallerIsBorrowerOperations();
        _syncGlobalAccounting();
    }

    function _syncGlobalAccounting() internal {
        (uint256 _oldIndex, uint256 _newIndex) = _readStEthIndex();
        _syncStEthIndex(_oldIndex, _newIndex);
        if (_newIndex > _oldIndex && totalStakes > 0) {
            (
                uint256 _feeTaken,
                uint256 _newFeePerUnit,
                uint256 _perUnitError
            ) = _calcSyncedGlobalAccounting(_newIndex, _oldIndex);
            _takeSplitAndUpdateFeePerUnit(_feeTaken, _newFeePerUnit, _perUnitError);
            _updateSystemSnapshotsExcludeCollRemainder(0);
        }
    }

    /// @notice Claim Fee Split, toggles Grace Period accordingly
    /// @notice Call this if you want to accrue feeSplit
    function syncGlobalAccountingAndGracePeriod() public {
        _syncGlobalAccounting(); // Apply // Could trigger RM
        _syncGracePeriod(); // Synch Grace Period
    }

    /// @return existing(old) local stETH index AND
    /// @return current(new) stETH index from collateral token
    function _readStEthIndex() internal view returns (uint256, uint256) {
        return (stEthIndex, collateral.getPooledEthByShares(DECIMAL_PRECISION));
    }

    // Update the global index via collateral token
    function _syncStEthIndex(uint256 _oldIndex, uint256 _newIndex) internal {
        if (_newIndex != _oldIndex) {
            stEthIndex = _newIndex;
            lastIndexTimestamp = block.timestamp;
            emit StEthIndexUpdated(_oldIndex, _newIndex, block.timestamp);
        }
    }

    // Calculate fee for given pair of collateral indexes, following are returned values:
    // - fee split in collateral token which will be deduced from current total system collateral
    // - fee split increase per unit, used to update systemStEthFeePerUnitIndex
    // - fee split calculation error, used to update systemStEthFeePerUnitIndexError
    function calcFeeUponStakingReward(
        uint256 _newIndex,
        uint256 _prevIndex
    ) public view returns (uint256, uint256, uint256) {
        require(_newIndex > _prevIndex, "CDPManager: only take fee with bigger new index");
        uint256 deltaIndex = _newIndex - _prevIndex;
        uint256 deltaIndexFees = (deltaIndex * stakingRewardSplit) / MAX_REWARD_SPLIT;

        // we take the fee for all CDPs immediately which is scaled by index precision
        uint256 _deltaFeeSplit = deltaIndexFees * getSystemCollShares();
        uint256 _cachedAllStakes = totalStakes;
        // return the values to update the global fee accumulator
        uint256 _feeTaken = collateral.getSharesByPooledEth(_deltaFeeSplit) / DECIMAL_PRECISION;
        uint256 _deltaFeeSplitShare = (_feeTaken * DECIMAL_PRECISION) +
            systemStEthFeePerUnitIndexError;
        uint256 _deltaFeePerUnit = _deltaFeeSplitShare / _cachedAllStakes;
        uint256 _perUnitError = _deltaFeeSplitShare - (_deltaFeePerUnit * _cachedAllStakes);
        return (_feeTaken, _deltaFeePerUnit, _perUnitError);
    }

    // Take the cut from staking reward
    // and update global fee-per-unit accumulator
    function _takeSplitAndUpdateFeePerUnit(
        uint256 _feeTaken,
        uint256 _newPerUnit,
        uint256 _newErrorPerUnit
    ) internal {
        uint256 _oldPerUnit = systemStEthFeePerUnitIndex;

        systemStEthFeePerUnitIndex = _newPerUnit;
        systemStEthFeePerUnitIndexError = _newErrorPerUnit;

        require(activePool.getSystemCollShares() > _feeTaken, "CDPManager: fee split is too big");
        activePool.allocateSystemCollSharesToFeeRecipient(_feeTaken);

        emit CollateralFeePerUnitUpdated(_oldPerUnit, _newPerUnit, _feeTaken);
    }

    // Apply accumulated fee split distributed to the CDP
    // and update its accumulator tracker accordingly
    function _applyAccumulatedFeeSplit(
        bytes32 _cdpId
    ) internal returns (uint256, uint256, uint256, uint256) {
        // TODO Ensure global states like systemStEthFeePerUnitIndex get timely updated
        // whenever there is a CDP modification operation,
        // such as opening, closing, adding collateral, repaying debt, or liquidating
        // OR Should we utilize some bot-keeper to work the routine job at fixed interval?
        _syncGlobalAccounting();

        uint256 _oldPerUnitCdp = stEthFeePerUnitIndex[_cdpId];
        uint256 _systemStEthFeePerUnitIndex = systemStEthFeePerUnitIndex;

        (
            uint256 _newColl,
            uint256 _newDebt,
            uint256 _feeSplitDistributed,
            uint _pendingDebt
        ) = _calcSyncedAccounting(_cdpId, _oldPerUnitCdp, _systemStEthFeePerUnitIndex);

        // apply split fee to given CDP
        if (_feeSplitDistributed > 0) {
            Cdps[_cdpId].coll = _newColl;

            emit CdpFeeSplitApplied(
                _cdpId,
                _oldPerUnitCdp,
                _systemStEthFeePerUnitIndex,
                _feeSplitDistributed,
                _newColl
            );
        }

        // sync per stake index for given CDP
        if (_oldPerUnitCdp != _systemStEthFeePerUnitIndex) {
            stEthFeePerUnitIndex[_cdpId] = _systemStEthFeePerUnitIndex;
        }

        return (_newColl, _newDebt, _feeSplitDistributed, _pendingDebt);
    }

    // return the applied split fee(scaled by 1e18) and the resulting CDP collateral amount after applied
    function getAccumulatedFeeSplitApplied(
        bytes32 _cdpId,
        uint256 _systemStEthFeePerUnitIndex
    ) public view returns (uint256, uint256) {
        uint256 _stEthFeePerUnitIndex = stEthFeePerUnitIndex[_cdpId];
        uint256 _cdpCol = Cdps[_cdpId].coll;

        if (
            _stEthFeePerUnitIndex == 0 ||
            _cdpCol == 0 ||
            _stEthFeePerUnitIndex == _systemStEthFeePerUnitIndex
        ) {
            return (0, _cdpCol);
        }

        uint256 _feeSplitDistributed = Cdps[_cdpId].stake *
            (_systemStEthFeePerUnitIndex - _stEthFeePerUnitIndex);

        uint256 _scaledCdpColl = _cdpCol * DECIMAL_PRECISION;

        if (_scaledCdpColl > _feeSplitDistributed) {
            return (
                _feeSplitDistributed,
                (_scaledCdpColl - _feeSplitDistributed) / DECIMAL_PRECISION
            );
        } else {
            // extreme unlikely case to skip fee split on this CDP to avoid revert
            return (0, _cdpCol);
        }
    }

    // -- Modifier functions --
    function _requireCdpIsActive(bytes32 _cdpId) internal view {
        require(Cdps[_cdpId].status == Status.active, "CdpManager: Cdp does not exist or is closed");
    }

    function _requireMoreThanOneCdpInSystem(uint256 CdpOwnersArrayLength) internal view {
        require(
            CdpOwnersArrayLength > 1 && sortedCdps.getSize() > 1,
            "CdpManager: Only one cdp in the system"
        );
    }

    function _requireCallerIsBorrowerOperations() internal view {
        require(
            msg.sender == borrowerOperationsAddress,
            "CdpManager: Caller is not the BorrowerOperations contract"
        );
    }

    // --- Helper functions ---

    // Return the nominal collateral ratio (ICR) of a given Cdp, without the price.
    // Takes a cdp's pending coll and debt rewards from redistributions into account.
    function getNominalICR(bytes32 _cdpId) external view returns (uint256) {
        (uint256 currentEBTCDebt, uint256 currentETH, ) = getDebtAndCollShares(_cdpId);

        uint256 NICR = LiquityMath._computeNominalCR(currentETH, currentEBTCDebt);
        return NICR;
    }

    // Return the nominal collateral ratio (ICR) of a given Cdp, without the price.
    // Takes a cdp's pending coll and debt rewards from redistributions into account.
    function getSyncedNominalICR(bytes32 _cdpId) external view returns (uint256) {
        (uint256 _oldIndex, uint256 _newIndex) = _readStEthIndex();
        (, uint256 _newGlobalSplitIdx, ) = _calcSyncedGlobalAccounting(_newIndex, _oldIndex);
        (uint256 _newColl, uint256 _newDebt, , uint256 _pendingDebt) = _calcSyncedAccounting(
            _cdpId,
            stEthFeePerUnitIndex[_cdpId],
            _newGlobalSplitIdx /// NOTE: This is latest index
        );

        uint256 NICR = LiquityMath._computeNominalCR(_newColl, _newDebt);
        return NICR;
    }

    // Return the current collateral ratio (ICR) of a given Cdp.
    //Takes a cdp's pending coll and debt rewards from redistributions into account.
    function getICR(bytes32 _cdpId, uint256 _price) public view returns (uint256) {
        (uint256 currentEBTCDebt, uint256 currentETH, ) = getDebtAndCollShares(_cdpId);
        uint256 ICR = _calculateCR(currentETH, currentEBTCDebt, _price);
        return ICR;
    }

    function _calculateCR(
        uint256 currentCollShare,
        uint256 currentDebt,
        uint256 _price
    ) internal view returns (uint256) {
        uint256 _underlyingCollateral = collateral.getPooledEthByShares(currentCollShare);
        return LiquityMath._computeCR(_underlyingCollateral, currentDebt, _price);
    }

    /**
    get the pending Cdp debt "reward" (i.e. the amount of extra debt assigned to the Cdp) from liquidation redistribution events, earned by their stake
    */
    function getPendingRedistributedDebt(
        bytes32 _cdpId
    ) public view returns (uint256 pendingEBTCDebtReward) {
        return _getPendingRedistributedDebt(_cdpId);
    }

    function hasPendingRedistributedDebt(bytes32 _cdpId) public view returns (bool) {
        return _hasRedistributedDebt(_cdpId);
    }

    // Return the Cdps entire debt and coll struct
    function _getDebtAndCollShares(
        bytes32 _cdpId
    ) internal view returns (CdpDebtAndCollShares memory) {
        (uint256 entireDebt, uint256 entireColl, uint256 pendingDebtReward) = getDebtAndCollShares(
            _cdpId
        );
        return CdpDebtAndCollShares(entireDebt, entireColl, pendingDebtReward);
    }

    // Return the Cdps entire debt and coll, including pending rewards from redistributions and collateral reduction from split fee.
    /// @notice pending rewards are included in the debt and coll totals returned.
    function getDebtAndCollShares(
        bytes32 _cdpId
    ) public view returns (uint256 debt, uint256 coll, uint256 pendingEBTCDebtReward) {
        (uint256 _newColl, uint256 _newDebt, , uint256 _pendingDebt) = _calcSyncedAccounting(
            _cdpId,
            stEthFeePerUnitIndex[_cdpId],
            systemStEthFeePerUnitIndex /// @audit This is not necessarily latest
        );
        coll = _newColl;
        debt = _newDebt;
        pendingEBTCDebtReward = _pendingDebt;
    }

    /// @dev calculate pending global state change to be applied:
    /// @return split fee taken (if any) AND
    /// @return new split index per stake unit AND
    /// @return new split index error
    function _calcSyncedGlobalAccounting(
        uint256 _newIndex,
        uint256 _oldIndex
    ) internal view returns (uint256, uint256, uint256) {
        if (_newIndex > _oldIndex && totalStakes > 0) {
            /// @audit-ok We don't take the fee if we had a negative rebase
            (
                uint256 _feeTaken,
                uint256 _deltaFeePerUnit,
                uint256 _perUnitError
            ) = calcFeeUponStakingReward(_newIndex, _oldIndex);

            // calculate new split per stake unit
            uint256 _newPerUnit = systemStEthFeePerUnitIndex + _deltaFeePerUnit;
            return (_feeTaken, _newPerUnit, _perUnitError);
        } else {
            return (0, systemStEthFeePerUnitIndex, systemStEthFeePerUnitIndexError);
        }
    }

    /// @dev calculate pending state change to be applied for given CDP and global split index(typically already synced):
    /// @return new CDP collateral share after pending change applied
    /// @return new CDP debt after pending change applied
    /// @return split fee applied to given CDP
    /// @return redistributed debt applied to given CDP
    function _calcSyncedAccounting(
        bytes32 _cdpId,
        uint256 _cdpPerUnitIdx,
        uint256 _systemStEthFeePerUnitIndex
    ) internal view returns (uint256, uint256, uint256, uint256) {
        uint256 _feeSplitApplied;
        uint256 _newCollShare = Cdps[_cdpId].coll;

        // processing split fee to be applied
        if (_cdpPerUnitIdx != _systemStEthFeePerUnitIndex && _cdpPerUnitIdx > 0) {
            (
                uint256 _feeSplitDistributed,
                uint256 _newCollShareAfter
            ) = getAccumulatedFeeSplitApplied(_cdpId, _systemStEthFeePerUnitIndex);
            _feeSplitApplied = _feeSplitDistributed;
            _newCollShare = _newCollShareAfter;
        }

        // processing redistributed debt to be applied
        (uint256 _newDebt, uint256 pendingDebtRedistributed) = _getSyncedCdpDebtAndRedistribution(
            _cdpId
        );

        return (_newCollShare, _newDebt, _feeSplitApplied, pendingDebtRedistributed);
    }

    /// @return CDP debt and pending redistribution from liquidation applied
    function _getSyncedCdpDebtAndRedistribution(
        bytes32 _cdpId
    ) internal view returns (uint256, uint256) {
        uint256 pendingDebtRedistributed = _getPendingRedistributedDebt(_cdpId);
        uint256 _newDebt = Cdps[_cdpId].debt;
        if (pendingDebtRedistributed > 0) {
            _newDebt = _newDebt + pendingDebtRedistributed;
        }
        return (_newDebt, pendingDebtRedistributed);
    }

    /// @return CDP debt with pending redistribution from liquidation applied
    function getSyncedCdpDebt(bytes32 _cdpId) public view returns (uint256) {
        (uint256 _newDebt, ) = _getSyncedCdpDebtAndRedistribution(_cdpId);
        return _newDebt;
    }

    /// @return CDP collateral with pending split fee applied
    function getSyncedCdpCollShares(bytes32 _cdpId) public view returns (uint256) {
        (uint256 _oldIndex, uint256 _newIndex) = _readStEthIndex();
        (, uint256 _newGlobalSplitIdx, ) = _calcSyncedGlobalAccounting(_newIndex, _oldIndex);
        (uint256 _newColl, , , ) = _calcSyncedAccounting(
            _cdpId,
            stEthFeePerUnitIndex[_cdpId],
            _newGlobalSplitIdx
        );
        return _newColl;
    }

    /// @return CDP ICR with pending collateral and debt change applied
    function getSyncedICR(bytes32 _cdpId, uint256 _price) public view returns (uint256) {
        uint256 _debt = getSyncedCdpDebt(_cdpId);
        uint256 _collShare = getSyncedCdpCollShares(_cdpId);
        return _calculateCR(_collShare, _debt, _price);
    }

    /// @return TCR with pending collateral and debt change applied
    function getSyncedTCR(uint256 _price) public view returns (uint256) {
        (uint256 _oldIndex, uint256 _newIndex) = _readStEthIndex();
        (uint256 _feeTaken, , ) = _calcSyncedGlobalAccounting(_newIndex, _oldIndex);

        uint256 _systemCollShare = activePool.getSystemCollShares();
        if (_feeTaken > 0) {
            _systemCollShare = _systemCollShare - _feeTaken;
        }
        uint256 _systemDebt = activePool.getSystemDebt();
        return _calculateCR(_systemCollShare, _systemDebt, _price);
    }

    // Can liquidate in RM if ICR < TCR AND Enough time has passed
    function canLiquidateRecoveryMode(uint256 icr, uint256 tcr) public view returns (bool) {
        // ICR < TCR and we have waited enough
        uint128 cachedLastGracePeriodStartTimestamp = lastGracePeriodStartTimestamp;
        return
            icr < tcr &&
            cachedLastGracePeriodStartTimestamp != UNSET_TIMESTAMP &&
            block.timestamp > cachedLastGracePeriodStartTimestamp + recoveryModeGracePeriod;
    }
}


Lines covered:	20 / 42 (47.6%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./Interfaces/ICollSurplusPool.sol";
import "./Dependencies/ICollateralToken.sol";
import "./Dependencies/SafeERC20.sol";
import "./Dependencies/ReentrancyGuard.sol";
import "./Dependencies/AuthNoOwner.sol";
import "./Interfaces/IActivePool.sol";

contract CollSurplusPool is ICollSurplusPool, ReentrancyGuard, AuthNoOwner {
    using SafeERC20 for IERC20;

    string public constant NAME = "CollSurplusPool";

    address public immutable borrowerOperationsAddress;
    address public immutable cdpManagerAddress;
    address public immutable activePoolAddress;
    address public immutable feeRecipientAddress;
    ICollateralToken public immutable collateral;

    // deposited ether tracker
    uint256 internal totalSurplusCollShares;
    // Collateral surplus claimable by cdp owners
    mapping(address => uint256) internal balances;

    // --- Contract setters ---

    /**
     * @notice Sets the addresses of the contracts and renounces ownership
     * @dev One-time initialization function. Can only be called by the owner as a security measure. Ownership is renounced after the function is called.
     * @param _borrowerOperationsAddress The address of the BorrowerOperations
     * @param _cdpManagerAddress The address of the CDPManager
     * @param _activePoolAddress The address of the ActivePool
     * @param _collTokenAddress The address of the CollateralToken
     */
    constructor(
        address _borrowerOperationsAddress,
        address _cdpManagerAddress,
        address _activePoolAddress,
        address _collTokenAddress
    ) {
        borrowerOperationsAddress = _borrowerOperationsAddress;
        cdpManagerAddress = _cdpManagerAddress;
        activePoolAddress = _activePoolAddress;
        collateral = ICollateralToken(_collTokenAddress);
        feeRecipientAddress = IActivePool(activePoolAddress).feeRecipientAddress();

        address _authorityAddress = address(AuthNoOwner(cdpManagerAddress).authority());
        if (_authorityAddress != address(0)) {
            _initializeAuthority(_authorityAddress);
        }
    }

    /**
     * @notice Gets the current collateral state variable of the pool
     * @dev Not necessarily equal to the raw collateral token balance - tokens can be forcibly sent to contracts
     * @return The current collateral balance tracked by the variable
     */
    function getTotalSurplusCollShares() external view override returns (uint256) {
        return totalSurplusCollShares;
    }

    /**
     * @notice Gets the collateral surplus available for the given account
     * @param _account The address of the account
     * @return The collateral balance available to claim
     */
    function getSurplusCollShares(address _account) external view override returns (uint256) {
        return balances[_account];
    }

    // --- Pool functionality ---

    function increaseSurplusCollShares(address _account, uint256 _amount) external override {
        _requireCallerIsCdpManager();

        uint256 newAmount = balances[_account] + _amount;
        balances[_account] = newAmount;

        emit SurplusCollSharesUpdated(_account, newAmount);
    }

    function claimSurplusCollShares(address _account) external override {
        _requireCallerIsBorrowerOperations();
        uint256 claimableColl = balances[_account];
        require(claimableColl > 0, "CollSurplusPool: No collateral available to claim");

        balances[_account] = 0;
        emit SurplusCollSharesUpdated(_account, 0);

        uint256 cachedTotalSurplusCollShares = totalSurplusCollShares;

        require(cachedTotalSurplusCollShares >= claimableColl, "!CollSurplusPoolBal");
        // Safe per the check above
        unchecked {
            totalSurplusCollShares = cachedTotalSurplusCollShares - claimableColl;
        }
        emit CollSharesTransferred(_account, claimableColl);

        // NOTE: No need for safe transfer if the collateral asset is standard. Make sure this is the case!
        collateral.transferShares(_account, claimableColl);
    }

    // --- 'require' functions ---

    function _requireCallerIsBorrowerOperations() internal view {
        require(
            msg.sender == borrowerOperationsAddress,
            "CollSurplusPool: Caller is not Borrower Operations"
        );
    }

    function _requireCallerIsCdpManager() internal view {
        require(msg.sender == cdpManagerAddress, "CollSurplusPool: Caller is not CdpManager");
    }

    function _requireCallerIsActivePool() internal view {
        require(msg.sender == activePoolAddress, "CollSurplusPool: Caller is not Active Pool");
    }

    function increaseTotalSurplusCollShares(uint256 _value) external override {
        _requireCallerIsActivePool();
        totalSurplusCollShares = totalSurplusCollShares + _value;
    }

    // === Governed Functions === //

    /// @dev Function to move unintended dust that are not protected
    /// @notice moves given amount of given token (collateral is NOT allowed)
    /// @notice because recipient are fixed, this function is safe to be called by anyone
    function sweepToken(address token, uint256 amount) public nonReentrant requiresAuth {
        require(token != address(collateral), "CollSurplusPool: Cannot Sweep Collateral");

        uint256 balance = IERC20(token).balanceOf(address(this));
        require(amount <= balance, "CollSurplusPool: Attempt to sweep more than balance");

        IERC20(token).safeTransfer(feeRecipientAddress, amount);

        emit SweepTokenSuccess(token, amount, feeRecipientAddress);
    }
}


Lines covered:	0 / 19 (0.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity 0.8.17;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}


Lines covered:	9 / 16 (56.2%)

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

import {Authority} from "./Authority.sol";

/// @notice Provides a flexible and updatable auth pattern which is completely separate from application logic.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Auth.sol)
/// @author Modified from Dappsys (https://github.com/dapphub/ds-auth/blob/master/src/auth.sol)
abstract contract Auth {
    event OwnershipTransferred(address indexed user, address indexed newOwner);

    event AuthorityUpdated(address indexed user, Authority indexed newAuthority);

    address public owner;

    Authority public authority;

    constructor(address _owner, Authority _authority) {
        owner = _owner;
        authority = _authority;

        emit OwnershipTransferred(msg.sender, _owner);
        emit AuthorityUpdated(msg.sender, _authority);
    }

    modifier requiresAuth() virtual {
        require(isAuthorized(msg.sender, msg.sig), "Auth: UNAUTHORIZED");

        _;
    }

    function isAuthorized(address user, bytes4 functionSig) internal view virtual returns (bool) {
        Authority auth = authority; // Memoizing authority saves us a warm SLOAD, around 100 gas.

        // Checking if the caller is the owner only after calling the authority saves gas in most cases, but be
        // aware that this makes protected functions uncallable even to the owner if the authority is out of order.
        return
            (address(auth) != address(0) && auth.canCall(user, address(this), functionSig)) ||
            user == owner;
    }

    function setAuthority(Authority newAuthority) public virtual {
        // We check if the caller is the owner first because we want to ensure they can
        // always swap out the authority even if it's reverting or using up a lot of gas.
        require(msg.sender == owner || authority.canCall(msg.sender, address(this), msg.sig));

        authority = newAuthority;

        emit AuthorityUpdated(msg.sender, newAuthority);
    }

    function transferOwnership(address newOwner) public virtual requiresAuth {
        owner = newOwner;

        emit OwnershipTransferred(msg.sender, newOwner);
    }
}


Lines covered:	11 / 19 (57.9%)

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

import {Authority} from "./Authority.sol";

/// @notice Provides a flexible and updatable auth pattern which is completely separate from application logic.
/// @author Modified by BadgerDAO to remove owner
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Auth.sol)
/// @author Modified from Dappsys (https://github.com/dapphub/ds-auth/blob/master/src/auth.sol)
contract AuthNoOwner {
    event AuthorityUpdated(address indexed user, Authority indexed newAuthority);

    Authority private _authority;
    bool private _authorityInitialized;

    modifier requiresAuth() virtual {
        require(isAuthorized(msg.sender, msg.sig), "Auth: UNAUTHORIZED");

        _;
    }

    function authority() public view returns (Authority) {
        return _authority;
    }

    function authorityInitialized() public view returns (bool) {
        return _authorityInitialized;
    }

    function isAuthorized(address user, bytes4 functionSig) internal view virtual returns (bool) {
        Authority auth = _authority; // Memoizing authority saves us a warm SLOAD, around 100 gas.

        // Checking if the caller is the owner only after calling the authority saves gas in most cases, but be
        // aware that this makes protected functions uncallable even to the owner if the authority is out of order.
        return (address(auth) != address(0) && auth.canCall(user, address(this), functionSig));
    }

    function setAuthority(address newAuthority) public virtual {
        // We check if the caller is the owner first because we want to ensure they can
        // always swap out the authority even if it's reverting or using up a lot of gas.
        require(_authority.canCall(msg.sender, address(this), msg.sig));

        _authority = Authority(newAuthority);

        // Once authority is set once via any means, ensure it is initialized
        if (!_authorityInitialized) {
            _authorityInitialized = true;
        }

        emit AuthorityUpdated(msg.sender, Authority(newAuthority));
    }

    /// @notice Changed constructor to initialize to allow flexiblity of constructor vs initializer use
    /// @notice sets authorityInitiailzed flag to ensure only one use of
    function _initializeAuthority(address newAuthority) internal {
        require(address(_authority) == address(0), "Auth: authority is non-zero");
        require(!_authorityInitialized, "Auth: authority already initialized");

        _authority = Authority(newAuthority);
        _authorityInitialized = true;

        emit AuthorityUpdated(address(this), Authority(newAuthority));
    }
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

/// @notice A generic interface for a contract which provides authorization data to an Auth instance.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Auth.sol)
/// @author Modified from Dappsys (https://github.com/dapphub/ds-auth/blob/master/src/auth.sol)
interface Authority {
    function canCall(address user, address target, bytes4 functionSig) external view returns (bool);
}


Lines covered:	1 / 2 (50.0%)

// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

contract BaseMath {
    uint256 public constant DECIMAL_PRECISION = 1e18;
}


Lines covered:	2 / 2 (100.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity 0.8.17;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}


Lines covered:	20 / 21 (95.2%)

//SPDX-License-Identifier: Unlicense
pragma solidity 0.8.17;

/**
  @title A library for deploying contracts EIP-3171 style.
  @author Agustin Aguilar <aa@horizon.io>
*/
library Create3 {
    error ErrorCreatingProxy();
    error ErrorCreatingContract();
    error TargetAlreadyExists();

    /**
    @notice The bytecode for a contract that proxies the creation of another contract
    @dev If this code is deployed using CREATE2 it can be used to decouple `creationCode` from the child contract address

  0x67363d3d37363d34f03d5260086018f3:
      0x00  0x67  0x67XXXXXXXXXXXXXXXX  PUSH8 bytecode  0x363d3d37363d34f0
      0x01  0x3d  0x3d                  RETURNDATASIZE  0 0x363d3d37363d34f0
      0x02  0x52  0x52                  MSTORE
      0x03  0x60  0x6008                PUSH1 08        8
      0x04  0x60  0x6018                PUSH1 18        24 8
      0x05  0xf3  0xf3                  RETURN

  0x363d3d37363d34f0:
      0x00  0x36  0x36                  CALLDATASIZE    cds
      0x01  0x3d  0x3d                  RETURNDATASIZE  0 cds
      0x02  0x3d  0x3d                  RETURNDATASIZE  0 0 cds
      0x03  0x37  0x37                  CALLDATACOPY
      0x04  0x36  0x36                  CALLDATASIZE    cds
      0x05  0x3d  0x3d                  RETURNDATASIZE  0 cds
      0x06  0x34  0x34                  CALLVALUE       val 0 cds
      0x07  0xf0  0xf0                  CREATE          addr
  */

    bytes internal constant PROXY_CHILD_BYTECODE =
        hex"67_36_3d_3d_37_36_3d_34_f0_3d_52_60_08_60_18_f3";

    //                        KECCAK256_PROXY_CHILD_BYTECODE = keccak256(PROXY_CHILD_BYTECODE);
    bytes32 internal constant KECCAK256_PROXY_CHILD_BYTECODE =
        0x21c35dbe1b344a2488cf3321d6ce542f8e9f305544ff09e4993a62319a497c1f;

    /**
    @notice Returns the size of the code on a given address
    @param _addr Address that may or may not contain code
    @return size of the code on the given `_addr`
  */
    function codeSize(address _addr) internal view returns (uint256 size) {
        assembly {
            size := extcodesize(_addr)
        }
    }

    /**
    @notice Creates a new contract with given `_creationCode` and `_salt`
    @param _salt Salt of the contract creation, resulting address will be derivated from this value only
    @param _creationCode Creation code (constructor) of the contract to be deployed, this value doesn't affect the resulting address
    @return addr of the deployed contract, reverts on error
  */
    function create3(bytes32 _salt, bytes memory _creationCode) internal returns (address addr) {
        return create3(_salt, _creationCode, 0);
    }

    /**
    @notice Creates a new contract with given `_creationCode` and `_salt`
    @param _salt Salt of the contract creation, resulting address will be derivated from this value only
    @param _creationCode Creation code (constructor) of the contract to be deployed, this value doesn't affect the resulting address
    @param _value In WEI of ETH to be forwarded to child contract
    @return addr of the deployed contract, reverts on error
  */
    function create3(
        bytes32 _salt,
        bytes memory _creationCode,
        uint256 _value
    ) internal returns (address addr) {
        // Creation code
        bytes memory creationCode = PROXY_CHILD_BYTECODE;

        // Get target final address
        addr = addressOf(_salt);
        if (codeSize(addr) != 0) revert TargetAlreadyExists();

        // Create CREATE2 proxy
        address proxy;
        assembly {
            proxy := create2(0, add(creationCode, 32), mload(creationCode), _salt)
        }
        if (proxy == address(0)) revert ErrorCreatingProxy();

        // Call proxy with final init code
        (bool success, ) = proxy.call{value: _value}(_creationCode);
        if (!success || codeSize(addr) == 0) revert ErrorCreatingContract();
    }

    /**
    @notice Computes the resulting address of a contract deployed using address(this) and the given `_salt`
    @param _salt Salt of the contract creation, resulting address will be derivated from this value only
    @return addr of the deployed contract, reverts on error

    @dev The address creation formula is: keccak256(rlp([keccak256(0xff ++ address(this) ++ _salt ++ keccak256(childBytecode))[12:], 0x01]))
  */
    function addressOf(bytes32 _salt) internal view returns (address) {
        address proxy = address(
            uint160(
                uint256(
                    keccak256(
                        abi.encodePacked(
                            hex"ff",
                            address(this),
                            _salt,
                            KECCAK256_PROXY_CHILD_BYTECODE
                        )
                    )
                )
            )
        );

        return address(uint160(uint256(keccak256(abi.encodePacked(hex"d6_94", proxy, hex"01")))));
    }
}


Lines covered:	1 / 5 (20.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "../Interfaces/IERC3156FlashLender.sol";
import "../Interfaces/IWETH.sol";

abstract contract ERC3156FlashLender is IERC3156FlashLender {
    // TODO: Fix / Finalize
    uint256 public constant MAX_BPS = 10_000;
    uint256 public constant MAX_FEE_BPS = 1_000; // 10%
    bytes32 public constant FLASH_SUCCESS_VALUE = keccak256("ERC3156FlashBorrower.onFlashLoan");

    // Functions to modify these variables must be included in impelemnting contracts if desired
    uint16 public feeBps = 3; // may be subject to future adjustments through protocol governance
    bool public flashLoansPaused;
}


Lines covered:	13 / 54 (24.1%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity 0.8.17;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

import "./IERC20.sol";

/**
 * Based on the stETH:
 *  -   https://docs.lido.fi/contracts/lido#
 */
interface ICollateralToken is IERC20 {
    // Returns the amount of shares that corresponds to _ethAmount protocol-controlled Ether
    function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);

    // Returns the amount of Ether that corresponds to _sharesAmount token shares
    function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);

    // Moves `_sharesAmount` token shares from the caller's account to the `_recipient` account.
    function transferShares(address _recipient, uint256 _sharesAmount) external returns (uint256);

    // Returns the amount of shares owned by _account
    function sharesOf(address _account) external view returns (uint256);

    // Returns authorized oracle address
    function getOracle() external view returns (address);
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

/**
 * Based on the stETH:
 *  -   https://docs.lido.fi/contracts/lido#
 */
interface ICollateralTokenOracle {
    // Return beacon specification data.
    function getBeaconSpec()
        external
        view
        returns (
            uint64 epochsPerFrame,
            uint64 slotsPerEpoch,
            uint64 secondsPerSlot,
            uint64 genesisTime
        );
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

/**
 * Based on the OpenZeppelin IER20 interface:
 * https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol
 *
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);

    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

/**
 * @dev Interface of the ERC2612 standard as defined in the EIP.
 *
 * Adds the {permit} method, which can be used to change one's
 * {IERC20-allowance} without having to send a transaction, by signing a
 * message. This allows users to spend tokens without having to hold Ether.
 *
 * See https://eips.ethereum.org/EIPS/eip-2612.
 *
 * Code adapted from https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2237/
 */
interface IERC2612 {
    /**
     * @dev Sets `amount` as the allowance of `spender` over `owner`'s tokens,
     * given `owner`'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 amount,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current ERC2612 nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases `owner`'s nonce by one. This
     * prevents a signature from being used multiple times.
     *
     * `owner` can limit the time a Permit is valid for by setting `deadline` to
     * a value in the near future. The deadline argument can be set to uint256(-1) to
     * create Permits that effectively never expire.
     */
    function nonces(address owner) external view returns (uint256);

    function version() external view returns (string memory);

    function permitTypeHash() external view returns (bytes32);

    function domainSeparator() external view returns (bytes32);
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

import "./EnumerableSet.sol";

/// @notice Role based Authority that supports up to 256 roles.
/// @author BadgerDAO
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/authorities/RolesAuthority.sol)
/// @author Modified from Dappsys (https://github.com/dapphub/ds-roles/blob/master/src/roles.sol)
interface IRolesAuthority {
    event UserRoleUpdated(address indexed user, uint8 indexed role, bool enabled);

    event PublicCapabilityUpdated(address indexed target, bytes4 indexed functionSig, bool enabled);
    event CapabilityBurned(address indexed target, bytes4 indexed functionSig);

    event RoleCapabilityUpdated(
        uint8 indexed role,
        address indexed target,
        bytes4 indexed functionSig,
        bool enabled
    );

    enum CapabilityFlag {
        None,
        Public,
        Burned
    }
}


Lines covered:	32 / 37 (86.5%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./BaseMath.sol";
import "./LiquityMath.sol";
import "../Interfaces/IActivePool.sol";
import "../Interfaces/IPriceFeed.sol";
import "../Interfaces/ILiquityBase.sol";
import "../Dependencies/ICollateralToken.sol";

/*
 * Base contract for CdpManager, BorrowerOperations. Contains global system constants and
 * common functions.
 */
contract LiquityBase is BaseMath, ILiquityBase {
    // Collateral Ratio applied for Liquidation Incentive
    // i.e., liquidator repay $1 worth of debt to get back $1.03 worth of collateral
    uint256 public constant LICR = 1030000000000000000; // 103%

    // Minimum collateral ratio for individual cdps
    uint256 public constant MCR = 1100000000000000000; // 110%

    // Critical system collateral ratio. If the system's total collateral ratio (TCR) falls below the CCR, Recovery Mode is triggered.
    uint256 public constant CCR = 1250000000000000000; // 125%

    // Amount of stETH collateral to be locked in active pool on opening cdps
    uint256 public constant LIQUIDATOR_REWARD = 2e17;

    // Minimum amount of stETH collateral a CDP must have
    uint256 public constant MIN_NET_COLL = 2e18;

    uint256 public constant PERCENT_DIVISOR = 200; // dividing by 200 yields 0.5%

    uint256 public constant BORROWING_FEE_FLOOR = 0; // 0.5%

    uint256 public constant STAKING_REWARD_SPLIT = 5_000; // taking 50% cut from staking reward

    uint256 public constant MAX_REWARD_SPLIT = 10_000;

    IActivePool public immutable activePool;

    IPriceFeed public immutable override priceFeed;

    // the only collateral token allowed in CDP
    ICollateralToken public immutable collateral;

    constructor(address _activePoolAddress, address _priceFeedAddress, address _collateralAddress) {
        activePool = IActivePool(_activePoolAddress);
        priceFeed = IPriceFeed(_priceFeedAddress);
        collateral = ICollateralToken(_collateralAddress);
    }

    // --- Gas compensation functions ---

    function _getNetColl(uint256 _coll) internal pure returns (uint256) {
        return _coll - LIQUIDATOR_REWARD;
    }

    /**
        @notice Get the entire system collateral
        @notice Entire system collateral = collateral stored in ActivePool, using their internal accounting
        @dev Coll stored for liquidator rewards or coll in CollSurplusPool are not included
     */
    function getSystemCollShares() public view returns (uint256 entireSystemColl) {
        return (activePool.getSystemCollShares());
    }

    /**
        @notice Get the entire system debt
        @notice Entire system collateral = collateral stored in ActivePool, using their internal accounting
     */
    function _getSystemDebt() internal view returns (uint256 entireSystemDebt) {
        return (activePool.getSystemDebt());
    }

    function _getTCR(uint256 _price) internal view returns (uint256 TCR) {
        (TCR, , ) = _getTCRWithSystemDebtAndCollShares(_price);
    }

    function _getTCRWithSystemDebtAndCollShares(
        uint256 _price
    ) internal view returns (uint256 TCR, uint256 _coll, uint256 _debt) {
        uint256 entireSystemColl = getSystemCollShares();
        uint256 entireSystemDebt = _getSystemDebt();

        uint256 _underlyingCollateral = collateral.getPooledEthByShares(entireSystemColl);
        TCR = LiquityMath._computeCR(_underlyingCollateral, entireSystemDebt, _price);

        return (TCR, entireSystemColl, entireSystemDebt);
    }

    function _checkRecoveryMode(uint256 _price) internal view returns (bool) {
        return _checkRecoveryModeForTCR(_getTCR(_price));
    }

    function _checkRecoveryModeForTCR(uint256 _tcr) internal view returns (bool) {
        return _tcr < CCR;
    }

    function _requireUserAcceptsFee(
        uint256 _fee,
        uint256 _amount,
        uint256 _maxFeePercentage
    ) internal pure {
        uint256 feePercentage = (_fee * DECIMAL_PRECISION) / _amount;
        require(feePercentage <= _maxFeePercentage, "Fee exceeded provided maximum");
    }

    // Convert debt denominated in ETH to debt denominated in BTC given that _price is ETH/BTC
    // _debt is denominated in ETH
    // _price is ETH/BTC
    function _convertDebtDenominationToBtc(
        uint256 _debt,
        uint256 _price
    ) internal pure returns (uint256) {
        return (_debt * _price) / DECIMAL_PRECISION;
    }
}


Lines covered:	32 / 36 (88.9%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

library LiquityMath {
    uint256 internal constant DECIMAL_PRECISION = 1e18;
    uint256 public constant MAX_TCR = type(uint256).max;

    /* Precision for Nominal ICR (independent of price). Rationale for the value:
     *
     * - Making it “too high” could lead to overflows.
     * - Making it “too low” could lead to an ICR equal to zero, due to truncation from Solidity floor division.
     *
     * This value of 1e20 is chosen for safety: the NICR will only overflow for numerator > ~1e39 ETH,
     * and will only truncate to 0 if the denominator is at least 1e20 times greater than the numerator.
     *
     */
    uint256 internal constant NICR_PRECISION = 1e20;

    function _min(uint256 _a, uint256 _b) internal pure returns (uint256) {
        return (_a < _b) ? _a : _b;
    }

    function _max(uint256 _a, uint256 _b) internal pure returns (uint256) {
        return (_a >= _b) ? _a : _b;
    }

    /*
     * Multiply two decimal numbers and use normal rounding rules:
     * -round product up if 19'th mantissa digit >= 5
     * -round product down if 19'th mantissa digit < 5
     *
     * Used only inside the exponentiation, _decPow().
     */
    function decMul(uint256 x, uint256 y) internal pure returns (uint256 decProd) {
        uint256 prod_xy = x * y;

        decProd = (prod_xy + (DECIMAL_PRECISION / 2)) / DECIMAL_PRECISION;
    }

    /*
     * _decPow: Exponentiation function for 18-digit decimal base, and integer exponent n.
     *
     * Uses the efficient "exponentiation by squaring" algorithm. O(log(n)) complexity.
     *
     * Called by two functions that represent time in units of minutes:
     * 1) CdpManager._calcDecayedBaseRate
     * 2) CommunityIssuance._getCumulativeIssuanceFraction
     *
     * The exponent is capped to avoid reverting due to overflow. The cap 525600000 equals
     * "minutes in 1000 years": 60 * 24 * 365 * 1000
     *
     * If a period of > 1000 years is ever used as an exponent in either of the above functions, the result will be
     * negligibly different from just passing the cap, since:
     *
     * In function 1), the decayed base rate will be 0 for 1000 years or > 1000 years
     * In function 2), the difference in tokens issued at 1000 years and any time > 1000 years, will be negligible
     */
    function _decPow(uint256 _base, uint256 _minutes) internal pure returns (uint256) {
        if (_minutes > 525600000) {
            _minutes = 525600000;
        } // cap to avoid overflow

        if (_minutes == 0) {
            return DECIMAL_PRECISION;
        }

        uint256 y = DECIMAL_PRECISION;
        uint256 x = _base;
        uint256 n = _minutes;

        // Exponentiation-by-squaring
        while (n > 1) {
            if (n % 2 == 0) {
                x = decMul(x, x);
                n = n / 2;
            } else {
                // if (n % 2 != 0)
                y = decMul(x, y);
                x = decMul(x, x);
                n = (n - 1) / 2;
            }
        }

        return decMul(x, y);
    }

    function _getAbsoluteDifference(uint256 _a, uint256 _b) internal pure returns (uint256) {
        return (_a >= _b) ? (_a - _b) : (_b - _a);
    }

    function _computeNominalCR(uint256 _coll, uint256 _debt) internal pure returns (uint256) {
        if (_debt > 0) {
            return (_coll * NICR_PRECISION) / _debt;
        }
        // Return the maximal value for uint256 if the Cdp has a debt of 0. Represents "infinite" CR.
        else {
            // if (_debt == 0)
            return MAX_TCR;
        }
    }

    function _computeCR(
        uint256 _coll,
        uint256 _debt,
        uint256 _price
    ) internal pure returns (uint256) {
        if (_debt > 0) {
            uint256 newCollRatio = (_coll * _price) / _debt;

            return newCollRatio;
        }
        // Return the maximal value for uint256 if the Cdp has a debt of 0. Represents "infinite" CR.
        else {
            // if (_debt == 0)
            return MAX_TCR;
        }
    }
}


Lines covered:	4 / 11 (36.4%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity 0.8.17;

import "./Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


Lines covered:	0 / 5 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;
import "../Interfaces/IPermitNonce.sol";

/**
 * @dev This abstract contract provides a mapping from address to nonce (uint256) used for permit signature
 */
contract PermitNonce is IPermitNonce {
    mapping(address => uint256) internal _nonces;

    /// @dev Increase current nonce for msg.sender by one.
    /// @notice This function could be used to invalidate any signed permit out there
    function increasePermitNonce() external returns (uint256) {
        return ++_nonces[msg.sender];
    }

    /// @dev Return current nonce for msg.sender fOR EIP-2612 compatibility
    function nonces(address owner) external view virtual returns (uint256) {
        return _nonces[owner];
    }
}


Lines covered:	7 / 8 (87.5%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)

pragma solidity 0.8.17;

/**
 * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
 * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
 * be specified by overriding the virtual {_implementation} function.
 *
 * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
 * different contract through the {_delegate} function.
 *
 * The success and return data of the delegated call will be returned back to the caller of the proxy.
 * @dev BadgerDAO: Simplified to the core delegation functionality, without any additional features.
 */
contract Proxy {
    /**
     * @dev Delegates the current call to `implementation`.
     *
     * This function does not return to its internal call site, it will return directly to the external caller.
     */
    function _delegate(address implementation) internal virtual {
        assembly {
            // Copy msg.data. We take full control of memory in this inline assembly
            // block because it will not return to Solidity code. We overwrite the
            // Solidity scratch pad at memory position 0.
            calldatacopy(0, 0, calldatasize())

            // Call the implementation.
            // out and outsize are 0 because we don't know the size yet.
            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)

            // Copy the returned data.
            returndatacopy(0, 0, returndatasize())

            switch result
            // delegatecall returns 0 on error.
            case 0 {
                revert(0, returndatasize())
            }
            default {
                return(0, returndatasize())
            }
        }
    }
}


Lines covered:	3 / 6 (50.0%)

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

/// @notice Gas optimized reentrancy protection for smart contracts.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/ReentrancyGuard.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol)
abstract contract ReentrancyGuard {
    uint256 internal constant OPEN = 1;
    uint256 internal constant LOCKED = 2;

    uint256 public locked = OPEN;

    modifier nonReentrant() virtual {
        require(locked == OPEN, "ReentrancyGuard: Reentrancy in nonReentrant call");

        locked = LOCKED;

        _;

        locked = OPEN;
    }
}


Lines covered:	17 / 43 (39.5%)

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

import {IRolesAuthority} from "./IRolesAuthority.sol";
import {Auth, Authority} from "./Auth.sol";
import "./EnumerableSet.sol";

/// @notice Role based Authority that supports up to 256 roles.
/// @author BadgerDAO
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/authorities/RolesAuthority.sol)
/// @author Modified from Dappsys (https://github.com/dapphub/ds-roles/blob/master/src/roles.sol)
contract RolesAuthority is IRolesAuthority, Auth, Authority {
    using EnumerableSet for EnumerableSet.Bytes32Set;
    using EnumerableSet for EnumerableSet.AddressSet;

    /*//////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(address _owner, Authority _authority) Auth(_owner, _authority) {}

    /*//////////////////////////////////////////////////////////////
                            ROLE/USER STORAGE
    //////////////////////////////////////////////////////////////*/

    EnumerableSet.AddressSet internal users;
    EnumerableSet.AddressSet internal targets;
    mapping(address => EnumerableSet.Bytes32Set) internal enabledFunctionSigsByTarget;

    EnumerableSet.Bytes32Set internal enabledFunctionSigsPublic;

    mapping(address => bytes32) public getUserRoles;

    mapping(address => mapping(bytes4 => CapabilityFlag)) public capabilityFlag;

    mapping(address => mapping(bytes4 => bytes32)) public getRolesWithCapability;

    function doesUserHaveRole(address user, uint8 role) public view virtual returns (bool) {
        return (uint256(getUserRoles[user]) >> role) & 1 != 0;
    }

    function doesRoleHaveCapability(
        uint8 role,
        address target,
        bytes4 functionSig
    ) public view virtual returns (bool) {
        return (uint256(getRolesWithCapability[target][functionSig]) >> role) & 1 != 0;
    }

    function isPublicCapability(address target, bytes4 functionSig) public view returns (bool) {
        return capabilityFlag[target][functionSig] == CapabilityFlag.Public;
    }

    /*//////////////////////////////////////////////////////////////
                           AUTHORIZATION LOGIC
    //////////////////////////////////////////////////////////////*/

    /**
        @notice A user can call a given function signature on a given target address if:
            - The capability has not been burned
            - That capability is public, or the user has a role that has been granted the capability to call the function
     */
    function canCall(
        address user,
        address target,
        bytes4 functionSig
    ) public view virtual override returns (bool) {
        CapabilityFlag flag = capabilityFlag[target][functionSig];

        if (flag == CapabilityFlag.Burned) {
            return false;
        } else if (flag == CapabilityFlag.Public) {
            return true;
        } else {
            return bytes32(0) != getUserRoles[user] & getRolesWithCapability[target][functionSig];
        }
    }

    /*//////////////////////////////////////////////////////////////
                   ROLE CAPABILITY CONFIGURATION LOGIC
    //////////////////////////////////////////////////////////////*/

    /// @notice Set a capability flag as public, meaning any account can call it. Or revoke this capability.
    /// @dev A capability cannot be made public if it has been burned.
    function setPublicCapability(
        address target,
        bytes4 functionSig,
        bool enabled
    ) public virtual requiresAuth {
        require(
            capabilityFlag[target][functionSig] != CapabilityFlag.Burned,
            "RolesAuthority: Capability Burned"
        );

        if (enabled) {
            capabilityFlag[target][functionSig] = CapabilityFlag.Public;
        } else {
            capabilityFlag[target][functionSig] = CapabilityFlag.None;
        }

        emit PublicCapabilityUpdated(target, functionSig, enabled);
    }

    /// @notice Grant a specified role the ability to call a function on a target.
    /// @notice Has no effect
    function setRoleCapability(
        uint8 role,
        address target,
        bytes4 functionSig,
        bool enabled
    ) public virtual requiresAuth {
        if (enabled) {
            getRolesWithCapability[target][functionSig] |= bytes32(1 << role);
            enabledFunctionSigsByTarget[target].add(bytes32(functionSig));

            if (!targets.contains(target)) {
                targets.add(target);
            }
        } else {
            getRolesWithCapability[target][functionSig] &= ~bytes32(1 << role);
            enabledFunctionSigsByTarget[target].remove(bytes32(functionSig));

            // If no enabled function signatures exist for this target, remove target
            if (enabledFunctionSigsByTarget[target].length() == 0) {
                targets.remove(target);
            }
        }

        emit RoleCapabilityUpdated(role, target, functionSig, enabled);
    }

    /// @notice Permanently burns a capability for a target.
    function burnCapability(address target, bytes4 functionSig) public virtual requiresAuth {
        require(
            capabilityFlag[target][functionSig] != CapabilityFlag.Burned,
            "RolesAuthority: Capability Burned"
        );
        capabilityFlag[target][functionSig] = CapabilityFlag.Burned;

        emit CapabilityBurned(target, functionSig);
    }

    /*//////////////////////////////////////////////////////////////
                       USER ROLE ASSIGNMENT LOGIC
    //////////////////////////////////////////////////////////////*/

    function setUserRole(address user, uint8 role, bool enabled) public virtual requiresAuth {
        if (enabled) {
            getUserRoles[user] |= bytes32(1 << role);

            if (!users.contains(user)) {
                users.add(user);
            }
        } else {
            getUserRoles[user] &= ~bytes32(1 << role);

            // Remove user if no more roles
            if (getUserRoles[user] == bytes32(0)) {
                users.remove(user);
            }
        }

        emit UserRoleUpdated(user, role, enabled);
    }
}


Lines covered:	0 / 5 (0.0%)

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity 0.8.17;

import "./IERC20.sol";
import "./Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    /// @dev Calls approve while checking bool return value, handles no-return tokens
    function safeApprove(IERC20 token, address spender, uint256 amount) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, amount));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
        );
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(
            data,
            "SafeERC20: low-level call failed"
        );
        require(
            returndata.length == 0 || abi.decode(returndata, (bool)),
            "SafeERC20: ERC20 operation did not succeed"
        );
    }
}


Lines covered:	0 / 1 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

/**
 * Based on OpenZeppelin's SafeMath:
 * https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/SafeMath.sol
 *
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     *
     * _Available since v2.4.0._
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}


Lines covered:	31 / 43 (72.1%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./Dependencies/Create3.sol";
import "./Dependencies/Ownable.sol";

contract EBTCDeployer is Ownable {
    string public constant name = "eBTC Deployer";

    string public constant AUTHORITY = "ebtc.v1.authority";
    string public constant LIQUIDATION_LIBRARY = "ebtc.v1.liquidationLibrary";
    string public constant CDP_MANAGER = "ebtc.v1.cdpManager";
    string public constant BORROWER_OPERATIONS = "ebtc.v1.borrowerOperations";

    string public constant PRICE_FEED = "ebtc.v1.priceFeed";
    string public constant SORTED_CDPS = "ebtc.v1.sortedCdps";

    string public constant ACTIVE_POOL = "ebtc.v1.activePool";
    string public constant COLL_SURPLUS_POOL = "ebtc.v1.collSurplusPool";

    string public constant HINT_HELPERS = "ebtc.v1.hintHelpers";
    string public constant EBTC_TOKEN = "ebtc.v1.eBTCToken";
    string public constant FEE_RECIPIENT = "ebtc.v1.feeRecipient";
    string public constant MULTI_CDP_GETTER = "ebtc.v1.multiCdpGetter";

    event ContractDeployed(address indexed contractAddress, string contractName, bytes32 salt);

    struct EbtcAddresses {
        address authorityAddress;
        address liquidationLibraryAddress;
        address cdpManagerAddress;
        address borrowerOperationsAddress;
        address priceFeedAddress;
        address sortedCdpsAddress;
        address activePoolAddress;
        address collSurplusPoolAddress;
        address hintHelpersAddress;
        address ebtcTokenAddress;
        address feeRecipientAddress;
        address multiCdpGetterAddress;
    }

    /**
    @notice Helper method to return a set of future addresses for eBTC. Intended to be used in the order specified.
    
    @dev The order is as follows:
    0: authority
    1: liquidationLibrary
    2: cdpManager
    3: borrowerOperations
    4: priceFeed
    5; sortedCdps
    6: activePool
    7: collSurplusPool
    8: hintHelpers
    9: eBTCToken
    10: feeRecipient
    11: multiCdpGetter


     */
    function getFutureEbtcAddresses() public view returns (EbtcAddresses memory) {
        EbtcAddresses memory addresses = EbtcAddresses(
            Create3.addressOf(keccak256(abi.encodePacked(AUTHORITY))),
            Create3.addressOf(keccak256(abi.encodePacked(LIQUIDATION_LIBRARY))),
            Create3.addressOf(keccak256(abi.encodePacked(CDP_MANAGER))),
            Create3.addressOf(keccak256(abi.encodePacked(BORROWER_OPERATIONS))),
            Create3.addressOf(keccak256(abi.encodePacked(PRICE_FEED))),
            Create3.addressOf(keccak256(abi.encodePacked(SORTED_CDPS))),
            Create3.addressOf(keccak256(abi.encodePacked(ACTIVE_POOL))),
            Create3.addressOf(keccak256(abi.encodePacked(COLL_SURPLUS_POOL))),
            Create3.addressOf(keccak256(abi.encodePacked(HINT_HELPERS))),
            Create3.addressOf(keccak256(abi.encodePacked(EBTC_TOKEN))),
            Create3.addressOf(keccak256(abi.encodePacked(FEE_RECIPIENT))),
            Create3.addressOf(keccak256(abi.encodePacked(MULTI_CDP_GETTER)))
        );

        return addresses;
    }

    /**
        @notice Deploy a contract using salt in string format and arbitrary runtime code.
        @dev Intended use is: get the future eBTC addresses, then deploy the appropriate contract to each address via this method, building the constructor using the mapped addresses
        @dev no enforcment of bytecode at address as we can't know the runtime code in this contract due to space constraints
        @dev gated to given deployer EOA to ensure no interference with process, given proper actions by deployer
     */
    function deploy(
        string memory _saltString,
        bytes memory _creationCode
    ) public returns (address deployedAddress) {
        bytes32 _salt = keccak256(abi.encodePacked(_saltString));
        deployedAddress = Create3.create3(_salt, _creationCode);
        emit ContractDeployed(deployedAddress, _saltString, _salt);
    }

    function deployWithCreationCodeAndConstructorArgs(
        string memory _saltString,
        bytes memory creationCode,
        bytes memory constructionArgs
    ) external returns (address) {
        bytes memory _data = abi.encodePacked(creationCode, constructionArgs);
        return deploy(_saltString, _data);
    }

    function deployWithCreationCode(
        string memory _saltString,
        bytes memory creationCode
    ) external returns (address) {
        return deploy(_saltString, creationCode);
    }

    function addressOf(string memory _saltString) external view returns (address) {
        bytes32 _salt = keccak256(abi.encodePacked(_saltString));
        return Create3.addressOf(_salt);
    }

    function addressOfSalt(bytes32 _salt) external view returns (address) {
        return Create3.addressOf(_salt);
    }

    /**
        @notice Create the creation code for a contract with the given runtime code.
        @dev credit: https://github.com/0xsequence/create3/blob/master/contracts/test_utils/Create3Imp.sol
     */
    function creationCodeFor(bytes memory _code) internal pure returns (bytes memory) {
        /*
      0x00    0x63         0x63XXXXXX  PUSH4 _code.length  size
      0x01    0x80         0x80        DUP1                size size
      0x02    0x60         0x600e      PUSH1 14            14 size size
      0x03    0x60         0x6000      PUSH1 00            0 14 size size
      0x04    0x39         0x39        CODECOPY            size
      0x05    0x60         0x6000      PUSH1 00            0 size
      0x06    0xf3         0xf3        RETURN
      <CODE>
    */

        return
            abi.encodePacked(hex"63", uint32(_code.length), hex"80_60_0E_60_00_39_60_00_F3", _code);
    }
}


Lines covered:	41 / 104 (39.4%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./Interfaces/IEBTCToken.sol";

import "./Dependencies/AuthNoOwner.sol";
import "./Dependencies/PermitNonce.sol";

/*
 *
 * Based upon OpenZeppelin's ERC20 contract:
 * https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol
 *
 * and their EIP2612 (ERC20Permit / ERC712) functionality:
 * https://github.com/OpenZeppelin/openzeppelin-contracts/blob/53516bc555a454862470e7860a9b5254db4d00f5/contracts/token/ERC20/ERC20Permit.sol
 *
 *
 * --- Functionality added specific to the EBTCToken ---
 *
 * 1) Transfer protection: blacklist of addresses that are invalid recipients (i.e. core Liquity contracts) in external
 * transfer() and transferFrom() calls. The purpose is to protect users from losing tokens by mistakenly sending EBTC directly to a Liquity
 * core contract, when they should rather call the right function.
 */

contract EBTCToken is IEBTCToken, AuthNoOwner, PermitNonce {
    uint256 private _totalSupply;
    string internal constant _NAME = "EBTC Stablecoin";
    string internal constant _SYMBOL = "EBTC";
    string internal constant _VERSION = "1";
    uint8 internal constant _DECIMALS = 18;

    // --- Data for EIP2612 ---

    // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    bytes32 private constant _PERMIT_TYPEHASH =
        0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
    // keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
    bytes32 private constant _TYPE_HASH =
        0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;

    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;

    // User data for EBTC token
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

    // --- Addresses ---
    address public immutable cdpManagerAddress;
    address public immutable borrowerOperationsAddress;

    constructor(
        address _cdpManagerAddress,
        address _borrowerOperationsAddress,
        address _authorityAddress
    ) {
        _initializeAuthority(_authorityAddress);

        cdpManagerAddress = _cdpManagerAddress;
        borrowerOperationsAddress = _borrowerOperationsAddress;

        bytes32 hashedName = keccak256(bytes(_NAME));
        bytes32 hashedVersion = keccak256(bytes(_VERSION));

        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = _chainID();
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(_TYPE_HASH, hashedName, hashedVersion);
    }

    // --- Functions for intra-Liquity calls ---

    /**
     * @notice Mint new tokens
     * @dev Internal system function - only callable by BorrowerOperations or CDPManager
     * @dev Governance can also expand the list of approved minters to enable other systems to mint tokens
     * @param _account The address to receive the newly minted tokens
     * @param _amount The amount of tokens to mint
     */
    function mint(address _account, uint256 _amount) external override {
        _requireCallerIsBOorCdpMOrAuth();
        _mint(_account, _amount);
    }

    /**
     * @notice Burn existing tokens
     * @dev Internal system function - only callable by BorrowerOperations or CDPManager
     * @dev Governance can also expand the list of approved burners to enable other systems to burn tokens
     * @param _account The address to burn tokens from
     * @param _amount The amount of tokens to burn
     */
    function burn(address _account, uint256 _amount) external override {
        _requireCallerIsBOorCdpMOrAuth();
        _burn(_account, _amount);
    }

    /**
     * @notice Burn existing tokens from caller
     * @dev Internal system function - only callable by BorrowerOperations or CDPManager
     * @dev Governance can also expand the list of approved burners to enable other systems to burn tokens
     * @param _amount The amount of tokens to burn
     */
    function burn(uint256 _amount) external {
        _requireCallerIsBOorCdpMOrAuth();
        _burn(msg.sender, _amount);
    }

    // --- External functions ---

    function totalSupply() external view override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) external view override returns (uint256) {
        return _balances[account];
    }

    function transfer(address recipient, uint256 amount) external override returns (bool) {
        _requireValidRecipient(recipient);
        _transfer(msg.sender, recipient, amount);
        return true;
    }

    function allowance(address owner, address spender) external view override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) external override returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external override returns (bool) {
        _requireValidRecipient(recipient);
        _transfer(sender, recipient, amount);

        uint256 cachedAllowance = _allowances[sender][msg.sender];
        if (cachedAllowance != type(uint256).max) {
            require(cachedAllowance >= amount, "ERC20: transfer amount exceeds allowance");
            unchecked {
                _approve(sender, msg.sender, cachedAllowance - amount);
            }
        }
        return true;
    }

    function increaseAllowance(
        address spender,
        uint256 addedValue
    ) external override returns (bool) {
        _approve(msg.sender, spender, _allowances[msg.sender][spender] + addedValue);
        return true;
    }

    function decreaseAllowance(
        address spender,
        uint256 subtractedValue
    ) external override returns (bool) {
        uint256 cachedAllowances = _allowances[msg.sender][spender];
        require(cachedAllowances >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(msg.sender, spender, cachedAllowances - subtractedValue);
        }
        return true;
    }

    // --- EIP 2612 Functionality (https://eips.ethereum.org/EIPS/eip-2612) ---

    function DOMAIN_SEPARATOR() external view returns (bytes32) {
        return domainSeparator();
    }

    function domainSeparator() public view override returns (bytes32) {
        if (_chainID() == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function permit(
        address owner,
        address spender,
        uint256 amount,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external override {
        require(deadline >= block.timestamp, "EBTC: expired deadline");
        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                domainSeparator(),
                keccak256(
                    abi.encode(_PERMIT_TYPEHASH, owner, spender, amount, _nonces[owner]++, deadline)
                )
            )
        );
        address recoveredAddress = ecrecover(digest, v, r, s);
        require(recoveredAddress == owner, "EBTC: invalid signature");
        _approve(owner, spender, amount);
    }

    /// @dev Return current nonce for msg.sender fOR EIP-2612 compatibility
    function nonces(address owner) external view override(IERC2612, PermitNonce) returns (uint256) {
        return _nonces[owner];
    }

    // --- Internal operations ---

    function _chainID() private view returns (uint256) {
        return block.chainid;
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 name,
        bytes32 version
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, name, version, _chainID(), address(this)));
    }

    // --- Internal operations ---
    // Warning: sanity checks (for sender and recipient) should have been done before calling these internal functions

    function _transfer(address sender, address recipient, uint256 amount) internal {
        require(sender != address(0), "EBTCToken: zero sender!");
        require(recipient != address(0), "EBTCToken: zero recipient!");

        uint256 cachedSenderBalances = _balances[sender];
        require(cachedSenderBalances >= amount, "ERC20: transfer amount exceeds balance");

        unchecked {
            // Safe because of the check above
            _balances[sender] = cachedSenderBalances - amount;
        }

        _balances[recipient] = _balances[recipient] + amount;
        emit Transfer(sender, recipient, amount);
    }

    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "EBTCToken: mint to zero recipient!");

        _totalSupply = _totalSupply + amount;
        _balances[account] = _balances[account] + amount;
        emit Transfer(address(0), account, amount);
    }

    function _burn(address account, uint256 amount) internal {
        require(account != address(0), "EBTCToken: burn from zero account!");

        uint256 cachedBalance = _balances[account];
        require(cachedBalance >= amount, "ERC20: burn amount exceeds balance");

        unchecked {
            // Safe because of the check above
            _balances[account] = cachedBalance - amount;
        }

        _totalSupply = _totalSupply - amount;
        emit Transfer(account, address(0), amount);
    }

    function _approve(address owner, address spender, uint256 amount) internal {
        require(owner != address(0), "EBTCToken: zero approve owner!");
        require(spender != address(0), "EBTCToken: zero approve spender!");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    // --- 'require' functions ---

    function _requireValidRecipient(address _recipient) internal view {
        require(
            _recipient != address(0) && _recipient != address(this),
            "EBTC: Cannot transfer tokens directly to the EBTC token contract or the zero address"
        );
        require(
            _recipient != cdpManagerAddress && _recipient != borrowerOperationsAddress,
            "EBTC: Cannot transfer tokens directly to the CdpManager or BorrowerOps"
        );
    }

    function _requireCallerIsBorrowerOperations() internal view {
        require(
            msg.sender == borrowerOperationsAddress,
            "EBTCToken: Caller is not BorrowerOperations"
        );
    }

    /// @dev authority check last to short-circuit in the case of use by usual immutable addresses
    function _requireCallerIsBOorCdpMOrAuth() internal view {
        require(
            msg.sender == borrowerOperationsAddress ||
                msg.sender == cdpManagerAddress ||
                isAuthorized(msg.sender, msg.sig),
            "EBTC: Caller is neither BorrowerOperations nor CdpManager nor authorized"
        );
    }

    function _requireCallerIsCdpM() internal view {
        require(msg.sender == cdpManagerAddress, "EBTC: Caller is not CdpManager");
    }

    // --- Optional functions ---

    function name() external pure override returns (string memory) {
        return _NAME;
    }

    function symbol() external pure override returns (string memory) {
        return _SYMBOL;
    }

    function decimals() external pure override returns (uint8) {
        return _DECIMALS;
    }

    function version() external pure override returns (string memory) {
        return _VERSION;
    }

    function permitTypeHash() external pure override returns (bytes32) {
        return _PERMIT_TYPEHASH;
    }
}


Lines covered:	2 / 8 (25.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./Dependencies/Ownable.sol";
import "./Dependencies/AuthNoOwner.sol";
import "./Dependencies/IERC20.sol";
import "./Dependencies/SafeERC20.sol";

/**
    @notice Minimal fee recipient
    @notice Tokens can be swept to owner address by authorized user
 */
contract FeeRecipient is Ownable, AuthNoOwner {
    using SafeERC20 for IERC20;
    // --- Events ---
    event SweepTokenSuccess(address indexed _token, uint256 _amount, address indexed _recipient);

    // --- Data ---
    string public constant NAME = "FeeRecipient";

    constructor(address _ownerAddress, address _authorityAddress) {
        _transferOwnership(_ownerAddress);
        _initializeAuthority(_authorityAddress);
    }

    // === Governed Functions === //

    /// @dev Function to move unintended dust that are not protected
    /// @notice moves given amount of given token (collateral is NOT allowed)
    /// @notice because recipient are fixed, this function is safe to be called by anyone
    function sweepToken(address token, uint256 amount) public requiresAuth {
        uint256 balance = IERC20(token).balanceOf(address(this));
        require(amount <= balance, "FeeRecipient: Attempt to sweep more than balance");

        address _owner = owner();
        IERC20(token).safeTransfer(_owner, amount);

        emit SweepTokenSuccess(token, amount, _owner);
    }
}


Lines covered:	4 / 66 (6.1%)

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

import {EnumerableSet} from "./Dependencies/EnumerableSet.sol";
import {Authority} from "./Dependencies/Auth.sol";
import {RolesAuthority} from "./Dependencies/RolesAuthority.sol";

/// @notice Role based Authority that supports up to 256 roles.
/// @notice We have taken the tradeoff of additional storage usage for easier readabiliy without using off-chain / indexing services.
/// @author BadgerDAO Expanded from Solmate RolesAuthority
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/authorities/RolesAuthority.sol)
/// @author Modified from Dappsys (https://github.com/dapphub/ds-roles/blob/master/src/roles.sol)
contract Governor is RolesAuthority {
    using EnumerableSet for EnumerableSet.Bytes32Set;
    using EnumerableSet for EnumerableSet.AddressSet;

    bytes32 NO_ROLES = bytes32(0);

    struct Role {
        uint8 roleId;
        string roleName;
    }

    struct Capability {
        address target;
        bytes4 functionSig;
        uint8[] roles;
    }

    /*//////////////////////////////////////////////////////////////
                            STORAGE
    //////////////////////////////////////////////////////////////*/

    mapping(uint8 => string) internal roleNames;

    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    event RoleNameSet(uint8 indexed role, string indexed name);

    /*//////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    /// @notice The contract constructor initializes RolesAuthority with the given owner.
    /// @param _owner The address of the owner, who gains all permissions by default.
    constructor(address _owner) RolesAuthority(_owner, Authority(address(this))) {}

    /*//////////////////////////////////////////////////////////////
                            GETTERS
    //////////////////////////////////////////////////////////////*/

    /// @notice Returns a list of users that are assigned a specific role.
    /// @dev This function searches all users and checks if they are assigned the given role.
    /// @dev Intended for off-chain utility only due to inefficiency.
    /// @param role The role ID to find users for.
    /// @return usersWithRole An array of addresses that are assigned the given role.

    function getUsersByRole(uint8 role) external view returns (address[] memory usersWithRole) {
        // Search over all users: O(n) * 2
        uint256 count;
        for (uint256 i = 0; i < users.length(); i++) {
            address user = users.at(i);
            bool _canCall = doesUserHaveRole(user, role);
            if (_canCall) {
                count += 1;
            }
        }
        if (count > 0) {
            uint256 j = 0;
            usersWithRole = new address[](count);
            address[] memory _usrs = users.values();
            for (uint256 i = 0; i < _usrs.length; i++) {
                address user = _usrs[i];
                bool _canCall = doesUserHaveRole(user, role);
                if (_canCall) {
                    usersWithRole[j] = user;
                    j++;
                }
            }
        }
    }

    /// @notice Returns a list of roles that an address has.
    /// @dev This function searches all roles and checks if they are assigned to the given user.
    /// @dev Intended for off-chain utility only due to inefficiency.
    /// @param user The address of the user.
    /// @return rolesForUser An array of role IDs that the user has.

    function getRolesForUser(address user) external view returns (uint8[] memory rolesForUser) {
        // Enumerate over all possible roles and check if enabled
        uint256 count;
        for (uint8 i = 0; i < type(uint8).max; i++) {
            if (doesUserHaveRole(user, i)) {
                count += 1;
            }
        }
        if (count > 0) {
            uint256 j = 0;
            rolesForUser = new uint8[](count);
            for (uint8 i = 0; i < type(uint8).max; i++) {
                if (doesUserHaveRole(user, i)) {
                    rolesForUser[j] = i;
                    j++;
                }
            }
        }
    }

    function getRolesFromByteMap(bytes32 byteMap) public pure returns (uint8[] memory roleIds) {
        uint256 count;
        for (uint8 i = 0; i < type(uint8).max; i++) {
            bool roleEnabled = (uint256(byteMap >> i) & 1) != 0;
            if (roleEnabled) {
                count += 1;
            }
        }
        if (count > 0) {
            uint256 j = 0;
            roleIds = new uint8[](count);
            for (uint8 i = 0; i < type(uint8).max; i++) {
                bool roleEnabled = (uint256(byteMap >> i) & 1) != 0;
                if (roleEnabled) {
                    roleIds[j] = i;
                    j++;
                }
            }
        }
    }

    // helper function to generate bytes32 cache data for given roleIds array
    function getByteMapFromRoles(uint8[] memory roleIds) public pure returns (bytes32) {
        bytes32 _data;
        for (uint8 i = 0; i < roleIds.length; i++) {
            _data |= bytes32(1 << uint256(roleIds[i]));
        }
        return _data;
    }

    // helper function to return every authorization-enabled function signatures for given target address
    function getEnabledFunctionsInTarget(
        address _target
    ) public view returns (bytes4[] memory _funcs) {
        bytes32[] memory _sigs = enabledFunctionSigsByTarget[_target].values();
        if (_sigs.length > 0) {
            _funcs = new bytes4[](_sigs.length);
            for (uint256 i = 0; i < _sigs.length; ++i) {
                _funcs[i] = bytes4(_sigs[i]);
            }
        }
    }

    /// @notice return all role IDs that have at least one capability enabled
    function getActiveRoles() external view returns (Role[] memory activeRoles) {
        revert("Planned off-chain QOL function, not yet implemented, please ignore for audit");
    }

    // If a role exists, flip enabled

    // Return all roles that are enabled anywhere

    function getCapabilitiesForTarget(
        address target
    ) external view returns (Capability[] memory capabilities) {
        revert("Planned off-chain QOL function, not yet implemented, please ignore for audit");
    }

    function getCapabilitiesByRole(
        uint8 role
    ) external view returns (Capability[] memory capabilities) {
        revert("Planned off-chain QOL function, not yet implemented, please ignore for audit");
    }

    function getRoleName(uint8 role) external view returns (string memory roleName) {
        return roleNames[role];
    }

    /*//////////////////////////////////////////////////////////////
                            AUTHORIZED SETTERS
    //////////////////////////////////////////////////////////////*/

    function setRoleName(uint8 role, string memory roleName) external requiresAuth {
        // TODO: require maximum size for a name
        roleNames[role] = roleName;

        emit RoleNameSet(role, roleName);
    }
}


Lines covered:	3 / 86 (3.5%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./Interfaces/ICdpManager.sol";
import "./Interfaces/ISortedCdps.sol";
import "./Dependencies/LiquityBase.sol";

contract HintHelpers is LiquityBase {
    string public constant NAME = "HintHelpers";

    ISortedCdps public immutable sortedCdps;
    ICdpManager public immutable cdpManager;

    // --- Events ---

    struct LocalVariables_getRedemptionHints {
        uint256 remainingEbtcToRedeem;
        uint256 minNetDebtInBTC;
        bytes32 currentCdpId;
        address currentCdpUser;
    }

    // --- Dependency setters ---
    constructor(
        address _sortedCdpsAddress,
        address _cdpManagerAddress,
        address _collateralAddress,
        address _activePoolAddress,
        address _priceFeedAddress
    ) LiquityBase(_activePoolAddress, _priceFeedAddress, _collateralAddress) {
        sortedCdps = ISortedCdps(_sortedCdpsAddress);
        cdpManager = ICdpManager(_cdpManagerAddress);
    }

    // --- Functions ---

    /**
     * @notice Get the redemption hints for the specified amount of eBTC, price and maximum number of iterations.
     * @param _EBTCamount The amount of eBTC to be redeemed.
     * @param _price The current price of the asset.
     * @param _maxIterations The maximum number of iterations to be performed.
     * @return firstRedemptionHint The identifier of the first CDP to be considered for redemption.
     * @return partialRedemptionHintNICR The new Nominal Collateral Ratio (NICR) of the CDP after partial redemption.
     * @return truncatedEBTCamount The actual amount of eBTC that can be redeemed.
     * @return partialRedemptionNewColl The new collateral amount after partial redemption.
     */
    function getRedemptionHints(
        uint256 _EBTCamount,
        uint256 _price,
        uint256 _maxIterations
    )
        external
        view
        returns (
            bytes32 firstRedemptionHint,
            uint256 partialRedemptionHintNICR,
            uint256 truncatedEBTCamount,
            uint256 partialRedemptionNewColl
        )
    {
        LocalVariables_getRedemptionHints memory vars;
        {
            vars.remainingEbtcToRedeem = _EBTCamount;
            vars.currentCdpId = sortedCdps.getLast();
            vars.currentCdpUser = sortedCdps.getOwnerAddress(vars.currentCdpId);

            while (
                vars.currentCdpUser != address(0) &&
                cdpManager.getICR(vars.currentCdpId, _price) < MCR
            ) {
                vars.currentCdpId = sortedCdps.getPrev(vars.currentCdpId);
                vars.currentCdpUser = sortedCdps.getOwnerAddress(vars.currentCdpId);
            }
            firstRedemptionHint = vars.currentCdpId;
        }

        if (_maxIterations == 0) {
            _maxIterations = type(uint256).max;
        }

        // Underflow is intentionally used in _maxIterations-- > 0
        unchecked {
            while (
                vars.currentCdpUser != address(0) &&
                vars.remainingEbtcToRedeem > 0 &&
                _maxIterations-- > 0
            ) {
                // Apply pending debt
                uint256 currentCdpDebt = cdpManager.getCdpDebt(vars.currentCdpId) +
                    cdpManager.getPendingRedistributedDebt(vars.currentCdpId);

                // If this CDP has more debt than the remaining to redeem, attempt a partial redemption
                if (currentCdpDebt > vars.remainingEbtcToRedeem) {
                    uint256 _cachedEbtcToRedeem = vars.remainingEbtcToRedeem;
                    (
                        partialRedemptionNewColl,
                        partialRedemptionHintNICR
                    ) = _calculateCdpStateAfterPartialRedemption(vars, currentCdpDebt, _price);

                    // If the partial redemption would leave the CDP with less than the minimum allowed coll, bail out of partial redemption and return only the fully redeemable
                    // TODO: This seems to return the original coll? why?
                    if (collateral.getPooledEthByShares(partialRedemptionNewColl) < MIN_NET_COLL) {
                        partialRedemptionHintNICR = 0; //reset to 0 as there is no partial redemption in this case
                        partialRedemptionNewColl = 0;
                        vars.remainingEbtcToRedeem = _cachedEbtcToRedeem;
                    } else {
                        vars.remainingEbtcToRedeem = 0;
                    }
                    break;
                } else {
                    vars.remainingEbtcToRedeem = vars.remainingEbtcToRedeem - currentCdpDebt;
                }

                vars.currentCdpId = sortedCdps.getPrev(vars.currentCdpId);
                vars.currentCdpUser = sortedCdps.getOwnerAddress(vars.currentCdpId);
            }
        }

        truncatedEBTCamount = _EBTCamount - vars.remainingEbtcToRedeem;
    }

    /**
     * @notice Calculate the partial redemption information.
     * @dev This is an internal function used by getRedemptionHints.
     * @param vars The local variables of the getRedemptionHints function.
     * @param currentCdpDebt The net eBTC debt of the CDP.
     * @param _price The current price of the asset.
     * @return newColl The new collateral amount after partial redemption.
     * @return newNICR The new Nominal Collateral Ratio (NICR) of the CDP after partial redemption.
     */
    function _calculateCdpStateAfterPartialRedemption(
        LocalVariables_getRedemptionHints memory vars,
        uint256 currentCdpDebt,
        uint256 _price
    ) internal view returns (uint256, uint256) {
        // maxReemable = min(remainingToRedeem, currentDebt)
        uint256 maxRedeemableEBTC = LiquityMath._min(vars.remainingEbtcToRedeem, currentCdpDebt);

        uint256 newColl;
        uint256 _oldIndex = cdpManager.stEthIndex();
        uint256 _newIndex = collateral.getPooledEthByShares(DECIMAL_PRECISION);

        if (_oldIndex < _newIndex) {
            newColl = _getCollateralWithSplitFeeApplied(vars.currentCdpId, _newIndex, _oldIndex);
        } else {
            (, newColl, ) = cdpManager.getDebtAndCollShares(vars.currentCdpId);
        }

        vars.remainingEbtcToRedeem = vars.remainingEbtcToRedeem - maxRedeemableEBTC;
        uint256 collToReceive = collateral.getSharesByPooledEth(
            (maxRedeemableEBTC * DECIMAL_PRECISION) / _price
        );

        uint256 _newCollAfter = newColl - collToReceive;
        return (
            _newCollAfter,
            LiquityMath._computeNominalCR(_newCollAfter, currentCdpDebt - maxRedeemableEBTC)
        );
    }

    /**
     * @notice Get the collateral amount of a CDP after applying split fee.
     * @dev This is an internal function used by _calculateCdpStateAfterPartialRedemption.
     * @param _cdpId The identifier of the CDP.
     * @param _newIndex The new index after the split fee is applied.
     * @param _oldIndex The old index before the split fee is applied.
     * @return newColl The new collateral amount after applying split fee.
     */
    function _getCollateralWithSplitFeeApplied(
        bytes32 _cdpId,
        uint256 _newIndex,
        uint256 _oldIndex
    ) internal view returns (uint256) {
        uint256 _deltaFeePerUnit;
        uint256 _newStFeePerUnit;
        uint256 _perUnitError;
        uint256 _feeTaken;

        (_feeTaken, _deltaFeePerUnit, _perUnitError) = cdpManager.calcFeeUponStakingReward(
            _newIndex,
            _oldIndex
        );
        _newStFeePerUnit = _deltaFeePerUnit + cdpManager.systemStEthFeePerUnitIndex();
        (, uint256 newColl) = cdpManager.getAccumulatedFeeSplitApplied(_cdpId, _newStFeePerUnit);
        return newColl;
    }

    /* getApproxHint() - return address of a Cdp that is, on average, (length / numTrials) positions away in the 
    sortedCdps list from the correct insert position of the Cdp to be inserted. 
    
    Note: The output address is worst-case O(n) positions away from the correct insert position, however, the function 
    is probabilistic. Input can be tuned to guarantee results to a high degree of confidence, e.g:

    Submitting numTrials = k * sqrt(length), with k = 15 makes it very, very likely that the ouput address will 
    be <= sqrt(length) positions away from the correct insert position.
    */
    function getApproxHint(
        uint256 _CR,
        uint256 _numTrials,
        uint256 _inputRandomSeed
    ) external view returns (bytes32 hint, uint256 diff, uint256 latestRandomSeed) {
        uint256 arrayLength = cdpManager.getActiveCdpsCount();

        if (arrayLength == 0) {
            return (sortedCdps.nonExistId(), 0, _inputRandomSeed);
        }

        hint = sortedCdps.getLast();
        diff = LiquityMath._getAbsoluteDifference(_CR, cdpManager.getNominalICR(hint));
        latestRandomSeed = _inputRandomSeed;

        uint256 i = 1;

        while (i < _numTrials) {
            latestRandomSeed = uint256(keccak256(abi.encodePacked(latestRandomSeed)));

            uint256 arrayIndex = latestRandomSeed % arrayLength;
            bytes32 _cId = cdpManager.getIdFromCdpIdsArray(arrayIndex);
            uint256 currentNICR = cdpManager.getNominalICR(_cId);

            // check if abs(current - CR) > abs(closest - CR), and update closest if current is closer
            uint256 currentDiff = LiquityMath._getAbsoluteDifference(currentNICR, _CR);

            if (currentDiff < diff) {
                diff = currentDiff;
                hint = _cId;
            }
            i++;
        }
    }

    /// @notice Compute nominal CR for a specified collateral and debt amount
    function computeNominalCR(uint256 _coll, uint256 _debt) external pure returns (uint256) {
        return LiquityMath._computeNominalCR(_coll, _debt);
    }

    /// @notice Compute CR for a specified collateral and debt amount
    function computeCR(
        uint256 _coll,
        uint256 _debt,
        uint256 _price
    ) external pure returns (uint256) {
        return LiquityMath._computeCR(_coll, _debt, _price);
    }
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./IPool.sol";

interface IActivePool is IPool {
    // --- Events ---
    event ActivePoolEBTCDebtUpdated(uint256 _EBTCDebt);
    event SystemCollSharesUpdated(uint256 _coll);
    event FeeRecipientAddressChanged(address _feeRecipientAddress);
    event FeeRecipientClaimableCollSharesIncreased(uint256 _coll, uint256 _fee);
    event FeeRecipientClaimableCollSharesDecreased(uint256 _coll, uint256 _fee);
    event FlashLoanSuccess(address _receiver, address _token, uint256 _amount, uint256 _fee);
    event SweepTokenSuccess(address indexed _token, uint256 _amount, address indexed _recipient);

    // --- Functions ---
    function transferSystemCollShares(address _account, uint256 _amount) external;

    function increaseSystemCollShares(uint256 _value) external;

    function transferSystemCollSharesAndLiquidatorReward(
        address _account,
        uint256 _shares,
        uint256 _liquidatorRewardShares
    ) external;

    function allocateSystemCollSharesToFeeRecipient(uint256 _shares) external;

    function claimFeeRecipientCollShares(uint256 _shares) external;

    function feeRecipientAddress() external view returns (address);

    function getFeeRecipientClaimableCollShares() external view returns (uint256);

    function setFeeRecipientAddress(address _feeRecipientAddress) external;
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;
import "./IPositionManagers.sol";

// Common interface for the Cdp Manager.
interface IBorrowerOperations is IPositionManagers {
    // --- Events ---

    event FeeRecipientAddressChanged(address _feeRecipientAddress);
    event FlashLoanSuccess(address _receiver, address _token, uint256 _amount, uint256 _fee);

    // --- Functions ---

    function openCdp(
        uint256 _EBTCAmount,
        bytes32 _upperHint,
        bytes32 _lowerHint,
        uint256 _stEthBalance
    ) external returns (bytes32);

    function openCdpFor(
        uint _EBTCAmount,
        bytes32 _upperHint,
        bytes32 _lowerHint,
        uint _collAmount,
        address _borrower
    ) external returns (bytes32);

    function addColl(
        bytes32 _cdpId,
        bytes32 _upperHint,
        bytes32 _lowerHint,
        uint256 _stEthBalanceIncrease
    ) external;

    function withdrawColl(
        bytes32 _cdpId,
        uint256 _stEthBalanceDecrease,
        bytes32 _upperHint,
        bytes32 _lowerHint
    ) external;

    function withdrawEBTC(
        bytes32 _cdpId,
        uint256 _amount,
        bytes32 _upperHint,
        bytes32 _lowerHint
    ) external;

    function repayEBTC(
        bytes32 _cdpId,
        uint256 _amount,
        bytes32 _upperHint,
        bytes32 _lowerHint
    ) external;

    function closeCdp(bytes32 _cdpId) external;

    function adjustCdp(
        bytes32 _cdpId,
        uint256 _stEthBalanceDecrease,
        uint256 _debtChange,
        bool isDebtIncrease,
        bytes32 _upperHint,
        bytes32 _lowerHint
    ) external;

    function adjustCdpWithColl(
        bytes32 _cdpId,
        uint256 _stEthBalanceDecrease,
        uint256 _debtChange,
        bool isDebtIncrease,
        bytes32 _upperHint,
        bytes32 _lowerHint,
        uint256 _stEthBalanceIncrease
    ) external;

    function claimSurplusCollShares() external;

    function feeRecipientAddress() external view returns (address);
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./ILiquityBase.sol";
import "./ICdpManagerData.sol";

// Common interface for the Cdp Manager.
interface ICdpManager is ILiquityBase, ICdpManagerData {
    // --- Functions ---
    function getActiveCdpsCount() external view returns (uint256);

    function getIdFromCdpIdsArray(uint256 _index) external view returns (bytes32);

    function liquidate(bytes32 _cdpId) external;

    function partiallyLiquidate(
        bytes32 _cdpId,
        uint256 _partialAmount,
        bytes32 _upperPartialHint,
        bytes32 _lowerPartialHint
    ) external;

    function batchLiquidateCdps(bytes32[] calldata _cdpArray) external;

    function redeemCollateral(
        uint256 _EBTCAmount,
        bytes32 _firstRedemptionHint,
        bytes32 _upperPartialRedemptionHint,
        bytes32 _lowerPartialRedemptionHint,
        uint256 _partialRedemptionHintNICR,
        uint256 _maxIterations,
        uint256 _maxFee
    ) external;

    function updateStakeAndTotalStakes(bytes32 _cdpId) external returns (uint256);

    function syncAccounting(bytes32 _cdpId) external;

    function getTotalStakeForFeeTaken(uint256 _feeTaken) external view returns (uint256, uint256);

    function closeCdp(bytes32 _cdpId, address _borrower, uint256 _debt, uint256 _coll) external;

    function removeStake(bytes32 _cdpId) external;

    function getRedemptionRate() external view returns (uint256);

    function getRedemptionRateWithDecay() external view returns (uint256);

    function getRedemptionFeeWithDecay(uint256 _ETHDrawn) external view returns (uint256);

    function decayBaseRateFromBorrowing() external;

    function getCdpStatus(bytes32 _cdpId) external view returns (uint256);

    function getCdpStake(bytes32 _cdpId) external view returns (uint256);

    function getCdpDebt(bytes32 _cdpId) external view returns (uint256);

    function getCdpCollShares(bytes32 _cdpId) external view returns (uint256);

    function getCdpLiquidatorRewardShares(bytes32 _cdpId) external view returns (uint);

    function initializeCdp(
        bytes32 _cdpId,
        uint256 _debt,
        uint256 _coll,
        uint256 _liquidatorRewardShares,
        address _borrower
    ) external;

    function updateCdp(
        bytes32 _cdpId,
        address _borrower,
        uint256 _coll,
        uint256 _debt,
        uint256 _newColl,
        uint256 _newDebt
    ) external;

    function getTCR(uint256 _price) external view returns (uint256);

    function checkRecoveryMode(uint256 _price) external view returns (bool);
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./ICollSurplusPool.sol";
import "./IEBTCToken.sol";
import "./ISortedCdps.sol";
import "./IActivePool.sol";
import "./IRecoveryModeGracePeriod.sol";
import "../Dependencies/ICollateralTokenOracle.sol";

// Common interface for the Cdp Manager.
interface ICdpManagerData is IRecoveryModeGracePeriod {
    // --- Events ---

    event FeeRecipientAddressChanged(address _feeRecipientAddress);
    event StakingRewardSplitSet(uint256 _stakingRewardSplit);
    event RedemptionFeeFloorSet(uint256 _redemptionFeeFloor);
    event MinuteDecayFactorSet(uint256 _minuteDecayFactor);
    event BetaSet(uint256 _beta);
    event RedemptionsPaused(bool _paused);

    event Liquidation(uint256 _liquidatedDebt, uint256 _liquidatedColl, uint256 _liqReward);
    event Redemption(
        uint256 _attemptedEBTCAmount,
        uint256 _actualEBTCAmount,
        uint256 _ETHSent,
        uint256 _ETHFee,
        address _redeemer
    );
    event CdpUpdated(
        bytes32 indexed _cdpId,
        address indexed _borrower,
        uint256 _oldDebt,
        uint256 _oldColl,
        uint256 _debt,
        uint256 _coll,
        uint256 _stake,
        CdpOperation _operation
    );
    event CdpLiquidated(
        bytes32 indexed _cdpId,
        address indexed _borrower,
        uint _debt,
        uint _coll,
        CdpOperation _operation,
        address _liquidator,
        uint _premiumToLiquidator
    );
    event CdpPartiallyLiquidated(
        bytes32 indexed _cdpId,
        address indexed _borrower,
        uint256 _debt,
        uint256 _coll,
        CdpOperation operation,
        address _liquidator,
        uint _premiumToLiquidator
    );
    event BaseRateUpdated(uint256 _baseRate);
    event LastRedemptionTimestampUpdated(uint256 _lastFeeOpTime);
    event TotalStakesUpdated(uint256 _newTotalStakes);
    event SystemSnapshotsUpdated(uint256 _totalStakesSnapshot, uint256 _totalCollateralSnapshot);
    event SystemDebtRedistributionIndexUpdated(uint256 _systemDebtRedistributionIndex);
    event CdpDebtRedistributionIndexUpdated(bytes32 _cdpId, uint256 _debtRedistributionIndex);
    event CdpArrayIndexUpdated(bytes32 _cdpId, uint256 _newIndex);
    event StEthIndexUpdated(uint256 _oldIndex, uint256 _newIndex, uint256 _updTimestamp);
    event CollateralFeePerUnitUpdated(uint256 _oldPerUnit, uint256 _newPerUnit, uint256 _feeTaken);
    event CdpFeeSplitApplied(
        bytes32 _cdpId,
        uint256 _oldPerUnitCdp,
        uint256 _newPerUnitCdp,
        uint256 _collReduced,
        uint256 collLeft
    );

    enum CdpOperation {
        openCdp,
        closeCdp,
        adjustCdp,
        syncAccounting,
        liquidateInNormalMode,
        liquidateInRecoveryMode,
        redeemCollateral,
        partiallyLiquidate
    }

    enum Status {
        nonExistent,
        active,
        closedByOwner,
        closedByLiquidation,
        closedByRedemption
    }

    // Store the necessary data for a cdp
    struct Cdp {
        uint256 debt;
        uint256 coll;
        uint256 stake;
        uint256 liquidatorRewardShares;
        Status status;
        uint128 arrayIndex;
    }

    /*
     * --- Variable container structs for liquidations ---
     *
     * These structs are used to hold, return and assign variables inside the liquidation functions,
     * in order to avoid the error: "CompilerError: Stack too deep".
     **/

    struct CdpDebtAndCollShares {
        uint256 entireDebt;
        uint256 entireColl;
        uint256 pendingDebtReward;
    }

    struct LiquidationLocals {
        bytes32 cdpId;
        uint256 partialAmount; // used only for partial liquidation, default 0 means full liquidation
        uint256 price;
        uint256 ICR;
        bytes32 upperPartialHint;
        bytes32 lowerPartialHint;
        bool recoveryModeAtStart;
        uint256 TCR;
        uint256 totalColSurplus;
        uint256 totalColToSend;
        uint256 totalDebtToBurn;
        uint256 totalDebtToRedistribute;
        uint256 totalColReward;
        bool sequenceLiq;
    }

    struct LiquidationRecoveryModeLocals {
        uint256 entireSystemDebt;
        uint256 entireSystemColl;
        uint256 totalDebtToBurn;
        uint256 totalColToSend;
        uint256 totalColSurplus;
        bytes32 cdpId;
        uint256 price;
        uint256 ICR;
        uint256 totalDebtToRedistribute;
        uint256 totalColReward;
        bool sequenceLiq;
    }

    struct LocalVariables_OuterLiquidationFunction {
        uint256 price;
        bool recoveryModeAtStart;
        uint256 liquidatedDebt;
        uint256 liquidatedColl;
    }

    struct LocalVariables_LiquidationSequence {
        uint256 i;
        uint256 ICR;
        bytes32 cdpId;
        bool backToNormalMode;
        uint256 entireSystemDebt;
        uint256 entireSystemColl;
        uint256 price;
        uint256 TCR;
    }

    struct SingleRedemptionInputs {
        bytes32 cdpId;
        uint256 maxEBTCamount;
        uint256 price;
        bytes32 upperPartialRedemptionHint;
        bytes32 lowerPartialRedemptionHint;
        uint256 partialRedemptionHintNICR;
    }

    struct LiquidationValues {
        uint256 entireCdpDebt;
        uint256 debtToOffset;
        uint256 totalCollToSendToLiquidator;
        uint256 debtToRedistribute;
        uint256 collSurplus;
        uint256 collReward;
    }

    struct LiquidationTotals {
        uint256 totalDebtInSequence;
        uint256 totalDebtToOffset;
        uint256 totalCollToSendToLiquidator;
        uint256 totalDebtToRedistribute;
        uint256 totalCollSurplus;
        uint256 totalCollReward;
    }

    // --- Variable container structs for redemptions ---

    struct RedemptionTotals {
        uint256 remainingEBTC;
        uint256 totalEBTCToRedeem;
        uint256 totalETHDrawn;
        uint256 totalCollSharesSurplus;
        uint256 ETHFee;
        uint256 ETHToSendToRedeemer;
        uint256 decayedBaseRate;
        uint256 price;
        uint256 totalEBTCSupplyAtStart;
        uint256 totalCollSharesAtStart;
        uint256 tcrAtStart;
    }

    struct SingleRedemptionValues {
        uint256 eBtcToRedeem;
        uint256 stEthToRecieve;
        uint256 collSurplus;
        uint256 liquidatorRewardShares;
        bool cancelledPartial;
        bool fullRedemption;
    }

    function totalStakes() external view returns (uint256);

    function ebtcToken() external view returns (IEBTCToken);

    function systemStEthFeePerUnitIndex() external view returns (uint256);

    function systemStEthFeePerUnitIndexError() external view returns (uint256);

    function stEthIndex() external view returns (uint256);

    function calcFeeUponStakingReward(
        uint256 _newIndex,
        uint256 _prevIndex
    ) external view returns (uint256, uint256, uint256);

    function syncGlobalAccounting() external; // Accrues StEthFeeSplit without influencing Grace Period

    function syncGlobalAccountingAndGracePeriod() external; // Accrues StEthFeeSplit and influences Grace Period

    function getAccumulatedFeeSplitApplied(
        bytes32 _cdpId,
        uint256 _systemStEthFeePerUnitIndex
    ) external view returns (uint256, uint256);

    function getNominalICR(bytes32 _cdpId) external view returns (uint256);

    function getICR(bytes32 _cdpId, uint256 _price) external view returns (uint256);

    function getSyncedCdpDebt(bytes32 _cdpId) external view returns (uint256);

    function getSyncedCdpCollShares(bytes32 _cdpId) external view returns (uint256);

    function getSyncedICR(bytes32 _cdpId, uint256 _price) external view returns (uint256);

    function getSyncedTCR(uint256 _price) external view returns (uint256);

    function getPendingRedistributedDebt(bytes32 _cdpId) external view returns (uint256);

    function hasPendingRedistributedDebt(bytes32 _cdpId) external view returns (bool);

    function getDebtAndCollShares(
        bytes32 _cdpId
    ) external view returns (uint256 debt, uint256 coll, uint256 pendingEBTCDebtReward);

    function canLiquidateRecoveryMode(uint256 icr, uint256 tcr) external view returns (bool);
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

interface ICollSurplusPool {
    // --- Events ---

    event SurplusCollSharesUpdated(address indexed _account, uint256 _newBalance);
    event CollSharesTransferred(address _to, uint256 _amount);

    event SweepTokenSuccess(address indexed _token, uint256 _amount, address indexed _recipient);

    // --- Contract setters ---

    function getTotalSurplusCollShares() external view returns (uint256);

    function getSurplusCollShares(address _account) external view returns (uint256);

    function increaseSurplusCollShares(address _account, uint256 _amount) external;

    function claimSurplusCollShares(address _account) external;

    function increaseTotalSurplusCollShares(uint256 _value) external;
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "../Dependencies/IERC20.sol";
import "../Dependencies/IERC2612.sol";

interface IEBTCToken is IERC20, IERC2612 {
    // --- Events ---
    event EBTCTokenBalanceUpdated(address _user, uint _amount);

    // --- Functions ---

    function mint(address _account, uint256 _amount) external;

    function burn(address _account, uint256 _amount) external;
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

interface IERC3156FlashBorrower {
    /**
     * @dev Receive a flash loan.
     * @param initiator The initiator of the loan.
     * @param token The loan currency.
     * @param amount The amount of tokens lent.
     * @param fee The additional amount of tokens to repay.
     * @param data Arbitrary data structure, intended to contain user-defined parameters.
     * @return The keccak256 hash of "ERC3156FlashBorrower.onFlashLoan"
     */
    function onFlashLoan(
        address initiator,
        address token,
        uint256 amount,
        uint256 fee,
        bytes calldata data
    ) external returns (bytes32);
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./IERC3156FlashBorrower.sol";

interface IERC3156FlashLender {
    event FlashFeeSet(address _setter, uint256 _oldFee, uint256 _newFee);
    event MaxFlashFeeSet(address _setter, uint256 _oldMaxFee, uint256 _newMaxFee);
    event FlashLoansPaused(address _setter, bool _paused);

    /**
     * @dev The amount of currency available to be lent.
     * @param token The loan currency.
     * @return The amount of `token` that can be borrowed.
     */
    function maxFlashLoan(address token) external view returns (uint256);

    /**
     * @dev The fee to be charged for a given loan.
     * @param token The loan currency.
     * @param amount The amount of tokens lent.
     * @return The amount of `token` to be charged for the loan, on top of the returned principal.
     */
    function flashFee(address token, uint256 amount) external view returns (uint256);

    /**
     * @dev Initiate a flash loan.
     * @param receiver The receiver of the tokens in the loan, and the receiver of the callback.
     * @param token The loan currency.
     * @param amount The amount of tokens lent.
     * @param data Arbitrary data structure, intended to contain user-defined parameters.
     */
    function flashLoan(
        IERC3156FlashBorrower receiver,
        address token,
        uint256 amount,
        bytes calldata data
    ) external returns (bool);
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

interface IFallbackCaller {
    // --- Events ---
    event FallbackTimeOutChanged(uint256 _oldTimeOut, uint256 _newTimeOut);

    // --- Function External View ---

    // NOTE: The fallback oracle must always return its answer scaled to 18 decimals where applicable
    //       The system will assume an 18 decimal response for efficiency.
    function getFallbackResponse() external view returns (uint256, uint256, bool);

    // NOTE: this returns the timeout window interval for the fallback oracle instead
    // of storing in the `PriceFeed` contract is retrieve for the `FallbackCaller`
    function fallbackTimeout() external view returns (uint256);

    // --- Function External Setter ---

    function setFallbackTimeout(uint256 newFallbackTimeout) external;
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./IPriceFeed.sol";

interface ILiquityBase {
    function priceFeed() external view returns (IPriceFeed);
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

interface IPermitNonce {
    // --- Functions ---
    function increasePermitNonce() external returns (uint256);

    function nonces(address owner) external view returns (uint256);
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

// Common interface for the Pools.
interface IPool {
    // --- Events ---

    event ETHBalanceUpdated(uint256 _newBalance);
    event EBTCBalanceUpdated(uint256 _newBalance);
    event CollSharesTransferred(address _to, uint256 _amount);

    // --- Functions ---

    function getSystemCollShares() external view returns (uint256);

    function getSystemDebt() external view returns (uint256);

    function increaseSystemDebt(uint256 _amount) external;

    function decreaseSystemDebt(uint256 _amount) external;
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

interface IPositionManagers {
    enum PositionManagerApproval {
        None,
        OneTime,
        Persistent
    }

    event PositionManagerApprovalSet(
        address _borrower,
        address _positionManager,
        PositionManagerApproval _approval
    );

    function getPositionManagerApproval(
        address _borrower,
        address _positionManager
    ) external view returns (PositionManagerApproval);

    function setPositionManagerApproval(
        address _positionManager,
        PositionManagerApproval _approval
    ) external;

    function revokePositionManagerApproval(address _positionManager) external;

    function renouncePositionManagerApproval(address _borrower) external;

    function permitPositionManagerApproval(
        address _borrower,
        address _positionManager,
        PositionManagerApproval _approval,
        uint _deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    function version() external view returns (string memory);

    function permitTypeHash() external view returns (bytes32);

    function domainSeparator() external view returns (bytes32);
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

interface IPriceFeed {
    // --- Events ---
    event LastGoodPriceUpdated(uint256 _lastGoodPrice);
    event PriceFeedStatusChanged(Status newStatus);
    event FallbackCallerChanged(address _oldFallbackCaller, address _newFallbackCaller);
    event UnhealthyFallbackCaller(address _fallbackCaller, uint256 timestamp);

    // --- Structs ---

    struct ChainlinkResponse {
        uint80 roundEthBtcId;
        uint80 roundStEthEthId;
        uint256 answer;
        uint256 timestampEthBtc;
        uint256 timestampStEthEth;
        bool success;
    }

    struct FallbackResponse {
        uint256 answer;
        uint256 timestamp;
        bool success;
    }

    // --- Enum ---

    enum Status {
        chainlinkWorking,
        usingFallbackChainlinkUntrusted,
        bothOraclesUntrusted,
        usingFallbackChainlinkFrozen,
        usingChainlinkFallbackUntrusted
    }

    // --- Function ---
    function fetchPrice() external returns (uint256);
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

// Interface for State Updates that can trigger RM Liquidations
interface IRecoveryModeGracePeriod {
    event TCRNotified(uint256 TCR); /// NOTE: Mostly for debugging to ensure synch

    // NOTE: Ts is implicit in events (it's added by GETH)
    event GracePeriodStart();
    event GracePeriodEnd();
    event GracePeriodSet(uint256 _recoveryModeGracePeriod);

    function notifyStartGracePeriod(uint256 tcr) external;

    function notifyEndGracePeriod(uint256 tcr) external;
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

// Common interface for the SortedCdps Doubly Linked List.
interface ISortedCdps {
    // --- Events ---

    event NodeAdded(bytes32 _id, uint _NICR);
    event NodeRemoved(bytes32 _id);

    // --- Functions ---

    function remove(bytes32 _id) external;

    function batchRemove(bytes32[] memory _ids) external;

    function reInsert(bytes32 _id, uint256 _newICR, bytes32 _prevId, bytes32 _nextId) external;

    function contains(bytes32 _id) external view returns (bool);

    function isFull() external view returns (bool);

    function isEmpty() external view returns (bool);

    function getSize() external view returns (uint256);

    function getMaxSize() external view returns (uint256);

    function getFirst() external view returns (bytes32);

    function getLast() external view returns (bytes32);

    function getNext(bytes32 _id) external view returns (bytes32);

    function getPrev(bytes32 _id) external view returns (bytes32);

    function validInsertPosition(
        uint256 _ICR,
        bytes32 _prevId,
        bytes32 _nextId
    ) external view returns (bool);

    function findInsertPosition(
        uint256 _ICR,
        bytes32 _prevId,
        bytes32 _nextId
    ) external view returns (bytes32, bytes32);

    function insert(
        address owner,
        uint256 _ICR,
        bytes32 _prevId,
        bytes32 _nextId
    ) external returns (bytes32);

    function getOwnerAddress(bytes32 _id) external pure returns (address);

    function nonExistId() external view returns (bytes32);

    function cdpCountOf(address owner) external view returns (uint256);

    function getCdpCountOf(
        address owner,
        bytes32 startNodeId,
        uint maxNodes
    ) external view returns (uint256, bytes32);

    function getCdpsOf(address owner) external view returns (bytes32[] memory);

    function getAllCdpsOf(
        address owner,
        bytes32 startNodeId,
        uint maxNodes
    ) external view returns (bytes32[] memory, uint256, bytes32);

    function cdpOfOwnerByIndex(address owner, uint256 index) external view returns (bytes32);

    function cdpOfOwnerByIdx(
        address owner,
        uint256 index,
        bytes32 startNodeId,
        uint maxNodes
    ) external view returns (bytes32, bool);
}


Lines covered:	0 / 0 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

interface IWETH {
    function deposit() external payable;

    function withdraw(uint256) external;

    function transfer(address to, uint256 amount) external returns (bool);

    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}


Lines covered:	440 / 486 (90.5%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;
import "./Interfaces/ICdpManagerData.sol";
import "./Interfaces/ICollSurplusPool.sol";
import "./Interfaces/IEBTCToken.sol";
import "./Interfaces/ISortedCdps.sol";
import "./Dependencies/ICollateralTokenOracle.sol";
import "./CdpManagerStorage.sol";

contract LiquidationLibrary is CdpManagerStorage {
    constructor(
        address _borrowerOperationsAddress,
        address _collSurplusPool,
        address _ebtcToken,
        address _sortedCdps,
        address _activePool,
        address _priceFeed,
        address _collateral
    )
        CdpManagerStorage(
            address(0),
            address(0),
            _borrowerOperationsAddress,
            _collSurplusPool,
            _ebtcToken,
            _sortedCdps,
            _activePool,
            _priceFeed,
            _collateral
        )
    {}

    /// @notice Single CDP liquidation function (fully).
    /// @notice callable by anyone, attempts to liquidate the CdpId. Executes successfully if Cdp meets the conditions for liquidation (e.g. in Normal Mode, it liquidates if the Cdp's ICR < the system MCR).
    function liquidate(bytes32 _cdpId) external nonReentrantSelfAndBOps {
        _liquidateIndividualCdpSetup(_cdpId, 0, _cdpId, _cdpId);
    }

    // Single CDP liquidation function (partially).
    function partiallyLiquidate(
        bytes32 _cdpId,
        uint256 _partialAmount,
        bytes32 _upperPartialHint,
        bytes32 _lowerPartialHint
    ) external nonReentrantSelfAndBOps {
        _liquidateIndividualCdpSetup(_cdpId, _partialAmount, _upperPartialHint, _lowerPartialHint);
    }

    // Single CDP liquidation function.
    function _liquidateIndividualCdpSetup(
        bytes32 _cdpId,
        uint256 _partialAmount,
        bytes32 _upperPartialHint,
        bytes32 _lowerPartialHint
    ) internal {
        _requireCdpIsActive(_cdpId);

        _syncAccounting(_cdpId);

        uint256 _price = priceFeed.fetchPrice();

        // prepare local variables
        uint256 _ICR = getICR(_cdpId, _price); // @audit syncAccounting already called, guarenteed to be synced
        (uint256 _TCR, uint256 systemColl, uint256 systemDebt) = _getTCRWithSystemDebtAndCollShares(
            _price
        );

        // If CDP is above MCR
        if (_ICR >= MCR) {
            // We must be in RM
            require(
                _TCR < CCR && _ICR <= _TCR, /// @audit is <= more dangerous? Should we use _ICR <= CCR to allow any risky CDP being liquidated?
                "CdpManager: ICR is not below liquidation threshold in current mode"
            );

            // == Grace Period == //
            uint128 cachedLastGracePeriodStartTimestamp = lastGracePeriodStartTimestamp;
            require(
                cachedLastGracePeriodStartTimestamp != UNSET_TIMESTAMP,
                "CdpManager: Recovery Mode grace period not started"
            );
            require(
                block.timestamp > cachedLastGracePeriodStartTimestamp + recoveryModeGracePeriod,
                "CdpManager: Recovery mode grace period still in effect"
            );
        } // Implicit Else Case, Implies ICR < MRC, meaning the CDP is liquidatable

        bool _recoveryModeAtStart = _TCR < CCR ? true : false;
        LiquidationLocals memory _liqState = LiquidationLocals(
            _cdpId,
            _partialAmount,
            _price,
            _ICR,
            _upperPartialHint,
            _lowerPartialHint,
            (_recoveryModeAtStart),
            _TCR,
            0,
            0,
            0,
            0,
            0,
            false
        );

        LiquidationRecoveryModeLocals memory _rs = LiquidationRecoveryModeLocals(
            systemDebt,
            systemColl,
            0,
            0,
            0,
            _cdpId,
            _price,
            _ICR,
            0,
            0,
            false
        );

        _liquidateIndividualCdpSetupCDP(_liqState, _rs);
    }

    // liquidate given CDP by repaying debt in full or partially if its ICR is below MCR or TCR in recovery mode.
    // For partial liquidation, caller should use HintHelper smart contract to get correct hints for reinsertion into sorted CDP list
    function _liquidateIndividualCdpSetupCDP(
        LiquidationLocals memory _liqState,
        LiquidationRecoveryModeLocals memory _recoveryState
    ) internal {
        LiquidationValues memory liquidationValues;

        uint256 startingSystemDebt = _recoveryState.entireSystemDebt;
        uint256 startingSystemColl = _recoveryState.entireSystemColl;

        if (_liqState.partialAmount == 0) {
            (
                liquidationValues.debtToOffset,
                liquidationValues.totalCollToSendToLiquidator,
                liquidationValues.debtToRedistribute,
                liquidationValues.collReward,
                liquidationValues.collSurplus
            ) = _liquidateCdpInGivenMode(_liqState, _recoveryState);
        } else {
            (
                liquidationValues.debtToOffset,
                liquidationValues.totalCollToSendToLiquidator
            ) = _liquidateCDPPartially(_liqState);
            if (
                liquidationValues.totalCollToSendToLiquidator == 0 &&
                liquidationValues.debtToOffset == 0
            ) {
                // retry with fully liquidation
                (
                    liquidationValues.debtToOffset,
                    liquidationValues.totalCollToSendToLiquidator,
                    liquidationValues.debtToRedistribute,
                    liquidationValues.collReward,
                    liquidationValues.collSurplus
                ) = _liquidateCdpInGivenMode(_liqState, _recoveryState);
            }
        }

        _finalizeLiquidation(
            liquidationValues.debtToOffset,
            liquidationValues.totalCollToSendToLiquidator,
            liquidationValues.debtToRedistribute,
            liquidationValues.collReward,
            liquidationValues.collSurplus,
            startingSystemColl,
            startingSystemDebt,
            _liqState.price
        );
    }

    // liquidate (and close) the CDP from an external liquidator
    // this function would return the liquidated debt and collateral of the given CDP
    function _liquidateCdpInGivenMode(
        LiquidationLocals memory _liqState,
        LiquidationRecoveryModeLocals memory _recoveryState
    ) private returns (uint256, uint256, uint256, uint256, uint256) {
        if (_liqState.recoveryModeAtStart) {
            LiquidationRecoveryModeLocals
                memory _outputState = _liquidateIndividualCdpSetupCDPInRecoveryMode(_recoveryState);

            // housekeeping leftover collateral for liquidated CDP
            if (_outputState.totalColSurplus > 0) {
                activePool.transferSystemCollShares(
                    address(collSurplusPool),
                    _outputState.totalColSurplus
                );
            }

            return (
                _outputState.totalDebtToBurn,
                _outputState.totalColToSend,
                _outputState.totalDebtToRedistribute,
                _outputState.totalColReward,
                _outputState.totalColSurplus
            );
        } else {
            LiquidationLocals memory _outputState = _liquidateIndividualCdpSetupCDPInNormalMode(
                _liqState
            );
            return (
                _outputState.totalDebtToBurn,
                _outputState.totalColToSend,
                _outputState.totalDebtToRedistribute,
                _outputState.totalColReward,
                _outputState.totalColSurplus
            );
        }
    }

    function _liquidateIndividualCdpSetupCDPInNormalMode(
        LiquidationLocals memory _liqState
    ) private returns (LiquidationLocals memory) {
        // liquidate entire debt
        (
            uint256 _totalDebtToBurn,
            uint256 _totalColToSend,
            uint256 _liquidatorReward
        ) = _closeCdpByLiquidation(_liqState.cdpId, _liqState.sequenceLiq);
        uint256 _cappedColPortion;
        uint256 _collSurplus;
        uint256 _debtToRedistribute;
        address _borrower = sortedCdps.getOwnerAddress(_liqState.cdpId);

        // I don't see an issue emitting the CdpUpdated() event up here and avoiding this extra cache, any objections?
        emit CdpUpdated(
            _liqState.cdpId,
            _borrower,
            _totalDebtToBurn,
            _totalColToSend,
            0,
            0,
            0,
            CdpOperation.liquidateInNormalMode
        );

        {
            (_cappedColPortion, _collSurplus, _debtToRedistribute) = _calculateSurplusAndCap(
                _liqState.ICR,
                _liqState.price,
                _totalDebtToBurn,
                _totalColToSend,
                true
            );
            if (_collSurplus > 0) {
                // due to division precision loss, should be zero surplus in normal mode
                _cappedColPortion = _cappedColPortion + _collSurplus;
                _collSurplus = 0;
            }
            if (_debtToRedistribute > 0) {
                _totalDebtToBurn = _totalDebtToBurn - _debtToRedistribute;
            }
        }
        _liqState.totalDebtToBurn = _liqState.totalDebtToBurn + _totalDebtToBurn;
        _liqState.totalColToSend = _liqState.totalColToSend + _cappedColPortion;
        _liqState.totalDebtToRedistribute = _liqState.totalDebtToRedistribute + _debtToRedistribute;
        _liqState.totalColReward = _liqState.totalColReward + _liquidatorReward;

        // Emit events
        uint _debtToColl = (_totalDebtToBurn * 1e18) / _liqState.price;
        uint _cappedColl = collateral.getPooledEthByShares(_cappedColPortion + _liquidatorReward);

        emit CdpLiquidated(
            _liqState.cdpId,
            _borrower,
            _totalDebtToBurn,
            _cappedColPortion,
            CdpOperation.liquidateInNormalMode,
            msg.sender,
            _cappedColl > _debtToColl ? (_cappedColl - _debtToColl) : 0
        );

        return _liqState;
    }

    function _liquidateIndividualCdpSetupCDPInRecoveryMode(
        LiquidationRecoveryModeLocals memory _recoveryState
    ) private returns (LiquidationRecoveryModeLocals memory) {
        // liquidate entire debt
        (
            uint256 _totalDebtToBurn,
            uint256 _totalColToSend,
            uint256 _liquidatorReward
        ) = _closeCdpByLiquidation(_recoveryState.cdpId, _recoveryState.sequenceLiq);

        // cap the liquidated collateral if required
        uint256 _cappedColPortion;
        uint256 _collSurplus;
        uint256 _debtToRedistribute;
        address _borrower = sortedCdps.getOwnerAddress(_recoveryState.cdpId);

        // I don't see an issue emitting the CdpUpdated() event up here and avoiding an extra cache of the values, any objections?
        emit CdpUpdated(
            _recoveryState.cdpId,
            _borrower,
            _totalDebtToBurn,
            _totalColToSend,
            0,
            0,
            0,
            CdpOperation.liquidateInRecoveryMode
        );

        // avoid stack too deep
        {
            (_cappedColPortion, _collSurplus, _debtToRedistribute) = _calculateSurplusAndCap(
                _recoveryState.ICR,
                _recoveryState.price,
                _totalDebtToBurn,
                _totalColToSend,
                true
            );
            if (_collSurplus > 0) {
                collSurplusPool.increaseSurplusCollShares(_borrower, _collSurplus);
                _recoveryState.totalColSurplus = _recoveryState.totalColSurplus + _collSurplus;
            }
            if (_debtToRedistribute > 0) {
                _totalDebtToBurn = _totalDebtToBurn - _debtToRedistribute;
            }
        }
        _recoveryState.totalDebtToBurn = _recoveryState.totalDebtToBurn + _totalDebtToBurn;
        _recoveryState.totalColToSend = _recoveryState.totalColToSend + _cappedColPortion;
        _recoveryState.totalDebtToRedistribute =
            _recoveryState.totalDebtToRedistribute +
            _debtToRedistribute;
        _recoveryState.totalColReward = _recoveryState.totalColReward + _liquidatorReward;

        // check if system back to normal mode
        _recoveryState.entireSystemDebt = _recoveryState.entireSystemDebt > _totalDebtToBurn
            ? _recoveryState.entireSystemDebt - _totalDebtToBurn
            : 0;
        _recoveryState.entireSystemColl = _recoveryState.entireSystemColl > _totalColToSend
            ? _recoveryState.entireSystemColl - _totalColToSend
            : 0;

        uint _debtToColl = (_totalDebtToBurn * 1e18) / _recoveryState.price;
        uint _cappedColl = collateral.getPooledEthByShares(_cappedColPortion + _liquidatorReward);
        emit CdpLiquidated(
            _recoveryState.cdpId,
            _borrower,
            _totalDebtToBurn,
            _cappedColPortion,
            CdpOperation.liquidateInRecoveryMode,
            msg.sender,
            _cappedColl > _debtToColl ? (_cappedColl - _debtToColl) : 0
        );

        return _recoveryState;
    }

    // liquidate (and close) the CDP from an external liquidator
    // this function would return the liquidated debt and collateral of the given CDP
    // without emmiting events
    function _closeCdpByLiquidation(
        bytes32 _cdpId,
        bool _sequenceLiq
    ) private returns (uint256, uint256, uint256) {
        // calculate entire debt to repay
        (uint256 entireDebt, uint256 entireColl, ) = getDebtAndCollShares(_cdpId);

        // housekeeping after liquidation by closing the CDP
        _removeStake(_cdpId);
        uint256 _liquidatorReward = Cdps[_cdpId].liquidatorRewardShares;
        if (_sequenceLiq) {
            _closeCdpWithoutRemovingSortedCdps(_cdpId, Status.closedByLiquidation);
        } else {
            _closeCdp(_cdpId, Status.closedByLiquidation);
        }

        return (entireDebt, entireColl, _liquidatorReward);
    }

    // Liquidate partially the CDP by an external liquidator
    // This function would return the liquidated debt and collateral of the given CDP
    function _liquidateCDPPartially(
        LiquidationLocals memory _partialState
    ) private returns (uint256, uint256) {
        bytes32 _cdpId = _partialState.cdpId;
        uint256 _partialDebt = _partialState.partialAmount;

        // calculate entire debt to repay
        CdpDebtAndCollShares memory _debtAndColl = _getDebtAndCollShares(_cdpId);
        _requirePartialLiqDebtSize(_partialDebt, _debtAndColl.entireDebt, _partialState.price);
        uint256 newDebt = _debtAndColl.entireDebt - _partialDebt;

        // credit to https://arxiv.org/pdf/2212.07306.pdf for details
        (uint256 _partialColl, uint256 newColl, ) = _calculateSurplusAndCap(
            _partialState.ICR,
            _partialState.price,
            _partialDebt,
            _debtAndColl.entireColl,
            false
        );

        // early return: if new collateral is zero, we have a full liqudiation
        if (newColl == 0) {
            return (0, 0);
        }

        // If we have coll remaining, it must meet minimum CDP size requirements
        _requirePartialLiqCollSize(collateral.getPooledEthByShares(newColl));

        // updating the CDP accounting for partial liquidation
        _partiallyReduceCdpDebt(_cdpId, _partialDebt, _partialColl);

        // reInsert into sorted CDP list after partial liquidation
        {
            _reInsertPartialLiquidation(
                _partialState,
                LiquityMath._computeNominalCR(newColl, newDebt),
                _debtAndColl.entireDebt,
                _debtAndColl.entireColl
            );
            uint _debtToColl = (_partialDebt * 1e18) / _partialState.price;
            uint _cappedColl = collateral.getPooledEthByShares(_partialColl);
            emit CdpPartiallyLiquidated(
                _cdpId,
                sortedCdps.getOwnerAddress(_cdpId),
                _partialDebt,
                _partialColl,
                CdpOperation.partiallyLiquidate,
                msg.sender,
                _cappedColl > _debtToColl ? (_cappedColl - _debtToColl) : 0
            );
        }
        return (_partialDebt, _partialColl);
    }

    function _partiallyReduceCdpDebt(
        bytes32 _cdpId,
        uint256 _partialDebt,
        uint256 _partialColl
    ) internal {
        Cdp storage _cdp = Cdps[_cdpId];

        uint256 _coll = _cdp.coll;
        uint256 _debt = _cdp.debt;

        _cdp.coll = _coll - _partialColl;
        _cdp.debt = _debt - _partialDebt;
        _updateStakeAndTotalStakes(_cdpId);

        _updateRedistributedDebtSnapshot(_cdpId);
    }

    // Re-Insertion into SortedCdp list after partial liquidation
    function _reInsertPartialLiquidation(
        LiquidationLocals memory _partialState,
        uint256 _newNICR,
        uint256 _oldDebt,
        uint256 _oldColl
    ) internal {
        bytes32 _cdpId = _partialState.cdpId;

        // ensure new ICR does NOT decrease due to partial liquidation
        // if original ICR is above LICR
        if (_partialState.ICR > LICR) {
            require(getICR(_cdpId, _partialState.price) >= _partialState.ICR, "!_newICR>=_ICR");
        }

        // reInsert into sorted CDP list
        sortedCdps.reInsert(
            _cdpId,
            _newNICR,
            _partialState.upperPartialHint,
            _partialState.lowerPartialHint
        );
        emit CdpUpdated(
            _cdpId,
            sortedCdps.getOwnerAddress(_cdpId),
            _oldDebt,
            _oldColl,
            Cdps[_cdpId].debt,
            Cdps[_cdpId].coll,
            Cdps[_cdpId].stake,
            CdpOperation.partiallyLiquidate
        );
    }

    function _finalizeLiquidation(
        uint256 totalDebtToBurn,
        uint256 totalColToSend,
        uint256 totalDebtToRedistribute,
        uint256 totalColReward,
        uint256 totalColSurplus,
        uint256 systemInitialCollShares,
        uint256 systemInitialDebt,
        uint256 price
    ) internal {
        // update the staking and collateral snapshots
        _updateSystemSnapshotsExcludeCollRemainder(totalColToSend);

        emit Liquidation(totalDebtToBurn, totalColToSend, totalColReward);

        _syncGracePeriodForGivenValues(
            systemInitialCollShares - totalColToSend - totalColSurplus,
            systemInitialDebt - totalDebtToBurn,
            price
        );

        // redistribute debt if any
        if (totalDebtToRedistribute > 0) {
            _redistributeDebt(totalDebtToRedistribute);
        }

        // burn the debt from liquidator
        ebtcToken.burn(msg.sender, totalDebtToBurn);

        // offset debt from Active Pool
        activePool.decreaseSystemDebt(totalDebtToBurn);

        // CEI: ensure sending back collateral to liquidator is last thing to do
        activePool.transferSystemCollSharesAndLiquidatorReward(
            msg.sender,
            totalColToSend,
            totalColReward
        );
    }

    // Function that calculates the amount of collateral to send to liquidator (plus incentive) and the amount of collateral surplus
    function _calculateSurplusAndCap(
        uint256 _ICR,
        uint256 _price,
        uint256 _totalDebtToBurn,
        uint256 _totalColToSend,
        bool _fullLiquidation
    )
        private
        view
        returns (uint256 cappedColPortion, uint256 collSurplus, uint256 debtToRedistribute)
    {
        // Calculate liquidation incentive for liquidator:
        // If ICR is less than 103%: give away 103% worth of collateral to liquidator, i.e., repaidDebt * 103% / price
        // If ICR is more than 103%: give away min(ICR, 110%) worth of collateral to liquidator, i.e., repaidDebt * min(ICR, 110%) / price
        uint256 _incentiveColl;
        if (_ICR > LICR) {
            _incentiveColl = (_totalDebtToBurn * (_ICR > MCR ? MCR : _ICR)) / _price;
        } else {
            if (_fullLiquidation) {
                // for full liquidation, there would be some bad debt to redistribute
                _incentiveColl = collateral.getPooledEthByShares(_totalColToSend);
                uint256 _debtToRepay = (_incentiveColl * _price) / LICR;
                debtToRedistribute = _debtToRepay < _totalDebtToBurn
                    ? _totalDebtToBurn - _debtToRepay
                    : 0;
            } else {
                // for partial liquidation, new ICR would deteriorate
                // since we give more incentive (103%) than current _ICR allowed
                _incentiveColl = (_totalDebtToBurn * LICR) / _price;
            }
        }
        cappedColPortion = collateral.getSharesByPooledEth(_incentiveColl);
        cappedColPortion = cappedColPortion < _totalColToSend ? cappedColPortion : _totalColToSend;
        collSurplus = (cappedColPortion == _totalColToSend) ? 0 : _totalColToSend - cappedColPortion;
    }

    // --- Batch liquidation functions ---

    function _getLiquidationValuesNormalMode(
        uint256 _price,
        uint256 _TCR,
        LocalVariables_LiquidationSequence memory vars,
        LiquidationValues memory singleLiquidation,
        bool sequenceLiq
    ) internal {
        LiquidationLocals memory _liqState = LiquidationLocals(
            vars.cdpId,
            0,
            _price,
            vars.ICR,
            vars.cdpId,
            vars.cdpId,
            (false),
            _TCR,
            0,
            0,
            0,
            0,
            0,
            sequenceLiq
        );

        LiquidationLocals memory _outputState = _liquidateIndividualCdpSetupCDPInNormalMode(
            _liqState
        );

        singleLiquidation.entireCdpDebt = _outputState.totalDebtToBurn;
        singleLiquidation.debtToOffset = _outputState.totalDebtToBurn;
        singleLiquidation.totalCollToSendToLiquidator = _outputState.totalColToSend;
        singleLiquidation.collSurplus = _outputState.totalColSurplus;
        singleLiquidation.debtToRedistribute = _outputState.totalDebtToRedistribute;
        singleLiquidation.collReward = _outputState.totalColReward;
    }

    function _getLiquidationValuesRecoveryMode(
        uint256 _price,
        uint256 _systemDebt,
        uint256 _systemCollShares,
        LocalVariables_LiquidationSequence memory vars,
        LiquidationValues memory singleLiquidation,
        bool sequenceLiq
    ) internal {
        LiquidationRecoveryModeLocals memory _recState = LiquidationRecoveryModeLocals(
            _systemDebt,
            _systemCollShares,
            0,
            0,
            0,
            vars.cdpId,
            _price,
            vars.ICR,
            0,
            0,
            sequenceLiq
        );

        LiquidationRecoveryModeLocals
            memory _outputState = _liquidateIndividualCdpSetupCDPInRecoveryMode(_recState);

        singleLiquidation.entireCdpDebt = _outputState.totalDebtToBurn;
        singleLiquidation.debtToOffset = _outputState.totalDebtToBurn;
        singleLiquidation.totalCollToSendToLiquidator = _outputState.totalColToSend;
        singleLiquidation.collSurplus = _outputState.totalColSurplus;
        singleLiquidation.debtToRedistribute = _outputState.totalDebtToRedistribute;
        singleLiquidation.collReward = _outputState.totalColReward;
    }

    /*
     * Attempt to liquidate a custom list of cdps provided by the caller.

     callable by anyone, accepts a custom list of Cdps addresses as an argument. Steps through the provided list and attempts to liquidate every Cdp, until it reaches the end or it runs out of gas. A Cdp is liquidated only if it meets the conditions for liquidation. For a batch of 10 Cdps, the gas costs per liquidated Cdp are roughly between 75K-83K, for a batch of 50 Cdps between 54K-69K.
     */
    function batchLiquidateCdps(bytes32[] memory _cdpArray) external nonReentrantSelfAndBOps {
        require(
            _cdpArray.length != 0,
            "LiquidationLibrary: Calldata address array must not be empty"
        );

        LocalVariables_OuterLiquidationFunction memory vars;
        LiquidationTotals memory totals;

        // taking fee to avoid accounted for the calculation of the TCR
        _syncGlobalAccounting();

        vars.price = priceFeed.fetchPrice();
        (uint256 _TCR, uint256 systemColl, uint256 systemDebt) = _getTCRWithSystemDebtAndCollShares(
            vars.price
        );
        vars.recoveryModeAtStart = _TCR < CCR ? true : false;

        // Perform the appropriate liquidation sequence - tally values and obtain their totals.
        if (vars.recoveryModeAtStart) {
            totals = _getTotalFromBatchLiquidate_RecoveryMode(
                vars.price,
                systemColl,
                systemDebt,
                _cdpArray,
                false
            );
        } else {
            //  if !vars.recoveryModeAtStart
            totals = _getTotalsFromBatchLiquidate_NormalMode(vars.price, _TCR, _cdpArray, false);
        }

        require(totals.totalDebtInSequence > 0, "LiquidationLibrary: nothing to liquidate");

        // housekeeping leftover collateral for liquidated CDPs
        if (totals.totalCollSurplus > 0) {
            activePool.transferSystemCollShares(address(collSurplusPool), totals.totalCollSurplus);
        }

        _finalizeLiquidation(
            totals.totalDebtToOffset,
            totals.totalCollToSendToLiquidator,
            totals.totalDebtToRedistribute,
            totals.totalCollReward,
            totals.totalCollSurplus,
            systemColl,
            systemDebt,
            vars.price
        );
    }

    /*
     * This function is used when the batch liquidation sequence starts during Recovery Mode. However, it
     * handle the case where the system *leaves* Recovery Mode, part way through the liquidation sequence
     */
    function _getTotalFromBatchLiquidate_RecoveryMode(
        uint256 _price,
        uint256 _systemCollShares,
        uint256 _systemDebt,
        bytes32[] memory _cdpArray,
        bool sequenceLiq
    ) internal returns (LiquidationTotals memory totals) {
        LocalVariables_LiquidationSequence memory vars;
        LiquidationValues memory singleLiquidation;

        vars.backToNormalMode = false;
        vars.entireSystemDebt = _systemDebt;
        vars.entireSystemColl = _systemCollShares;
        uint256 _TCR = _computeTCRWithGivenSystemValues(
            vars.entireSystemColl,
            vars.entireSystemDebt,
            _price
        );
        uint256 _cnt = _cdpArray.length;
        bool[] memory _liqFlags = new bool[](_cnt);
        uint256 _liqCnt;
        uint256 _start = sequenceLiq ? _cnt - 1 : 0;
        for (vars.i = _start; ; ) {
            vars.cdpId = _cdpArray[vars.i];
            // only for active cdps
            if (vars.cdpId != bytes32(0) && Cdps[vars.cdpId].status == Status.active) {
                vars.ICR = getSyncedICR(vars.cdpId, _price);

                if (
                    !vars.backToNormalMode &&
                    (vars.ICR < MCR || canLiquidateRecoveryMode(vars.ICR, _TCR))
                ) {
                    vars.price = _price;
                    _syncAccounting(vars.cdpId);
                    _getLiquidationValuesRecoveryMode(
                        _price,
                        vars.entireSystemDebt,
                        vars.entireSystemColl,
                        vars,
                        singleLiquidation,
                        sequenceLiq
                    );

                    // Update aggregate trackers
                    vars.entireSystemDebt = vars.entireSystemDebt - singleLiquidation.debtToOffset;
                    vars.entireSystemColl =
                        vars.entireSystemColl -
                        singleLiquidation.totalCollToSendToLiquidator -
                        singleLiquidation.collSurplus;

                    // Add liquidation values to their respective running totals
                    totals = _addLiquidationValuesToTotals(totals, singleLiquidation);

                    _TCR = _computeTCRWithGivenSystemValues(
                        vars.entireSystemColl,
                        vars.entireSystemDebt,
                        _price
                    );
                    vars.backToNormalMode = _TCR < CCR ? false : true;
                    _liqFlags[vars.i] = true;
                    _liqCnt += 1;
                } else if (vars.backToNormalMode && vars.ICR < MCR) {
                    _syncAccounting(vars.cdpId);
                    _getLiquidationValuesNormalMode(
                        _price,
                        _TCR,
                        vars,
                        singleLiquidation,
                        sequenceLiq
                    );

                    // Add liquidation values to their respective running totals
                    totals = _addLiquidationValuesToTotals(totals, singleLiquidation);
                    _liqFlags[vars.i] = true;
                    _liqCnt += 1;
                }
                // In Normal Mode skip cdps with ICR >= MCR
            }
            if (sequenceLiq) {
                if (vars.i == 0) {
                    break;
                }
                --vars.i;
            } else {
                ++vars.i;
                if (vars.i == _cnt) {
                    break;
                }
            }
        }

        // remove from sortedCdps for sequence liquidation
        if (sequenceLiq) {
            bytes32[] memory _toRemoveIds = _cdpArray;
            if (_liqCnt > 0 && _liqCnt != _cnt) {
                _toRemoveIds = new bytes32[](_liqCnt);
                uint256 _j;
                for (uint256 i = 0; i < _cnt; ++i) {
                    if (_liqFlags[i]) {
                        _toRemoveIds[_j] = _cdpArray[i];
                        _j += 1;
                    }
                }
                require(
                    _j == _liqCnt,
                    "LiquidationLibrary: sequence liquidation (recovery mode) count error!"
                );
            }
            if (_liqCnt > 1) {
                sortedCdps.batchRemove(_toRemoveIds);
            } else if (_liqCnt == 1) {
                sortedCdps.remove(_toRemoveIds[0]);
            }
        }
    }

    function _getTotalsFromBatchLiquidate_NormalMode(
        uint256 _price,
        uint256 _TCR,
        bytes32[] memory _cdpArray,
        bool sequenceLiq
    ) internal returns (LiquidationTotals memory totals) {
        LocalVariables_LiquidationSequence memory vars;
        LiquidationValues memory singleLiquidation;
        uint256 _cnt = _cdpArray.length;
        uint256 _liqCnt;
        uint256 _start = sequenceLiq ? _cnt - 1 : 0;
        for (vars.i = _start; ; ) {
            vars.cdpId = _cdpArray[vars.i];
            // only for active cdps
            if (vars.cdpId != bytes32(0) && Cdps[vars.cdpId].status == Status.active) {
                vars.ICR = getSyncedICR(vars.cdpId, _price);

                if (vars.ICR < MCR) {
                    _syncAccounting(vars.cdpId);
                    _getLiquidationValuesNormalMode(
                        _price,
                        _TCR,
                        vars,
                        singleLiquidation,
                        sequenceLiq
                    );

                    // Add liquidation values to their respective running totals
                    totals = _addLiquidationValuesToTotals(totals, singleLiquidation);
                    _liqCnt += 1;
                }
            }
            if (sequenceLiq) {
                if (vars.i == 0) {
                    break;
                }
                --vars.i;
            } else {
                ++vars.i;
                if (vars.i == _cnt) {
                    break;
                }
            }
        }

        // remove from sortedCdps for sequence liquidation
        if (sequenceLiq) {
            require(
                _liqCnt == _cnt,
                "LiquidationLibrary: sequence liquidation (normal mode) count error!"
            );
            if (_cnt > 1) {
                sortedCdps.batchRemove(_cdpArray);
            } else if (_cnt == 1) {
                sortedCdps.remove(_cdpArray[0]);
            }
        }
    }

    // --- Liquidation helper functions ---

    function _addLiquidationValuesToTotals(
        LiquidationTotals memory oldTotals,
        LiquidationValues memory singleLiquidation
    ) internal pure returns (LiquidationTotals memory newTotals) {
        // Tally all the values with their respective running totals
        newTotals.totalDebtInSequence =
            oldTotals.totalDebtInSequence +
            singleLiquidation.entireCdpDebt;
        newTotals.totalDebtToOffset = oldTotals.totalDebtToOffset + singleLiquidation.debtToOffset;
        newTotals.totalCollToSendToLiquidator =
            oldTotals.totalCollToSendToLiquidator +
            singleLiquidation.totalCollToSendToLiquidator;
        newTotals.totalDebtToRedistribute =
            oldTotals.totalDebtToRedistribute +
            singleLiquidation.debtToRedistribute;
        newTotals.totalCollSurplus = oldTotals.totalCollSurplus + singleLiquidation.collSurplus;
        newTotals.totalCollReward = oldTotals.totalCollReward + singleLiquidation.collReward;

        return newTotals;
    }

    function _redistributeDebt(uint256 _debt) internal {
        if (_debt == 0) {
            return;
        }

        /*
         * Add distributed debt rewards-per-unit-staked to the running totals. Division uses a "feedback"
         * error correction, to keep the cumulative error low in the running totals systemDebtRedistributionIndex:
         *
         * 1) Form numerators which compensate for the floor division errors that occurred the last time this
         * function was called.
         * 2) Calculate "per-unit-staked" ratios.
         * 3) Multiply each ratio back by its denominator, to reveal the current floor division error.
         * 4) Store these errors for use in the next correction when this function is called.
         * 5) Note: static analysis tools complain about this "division before multiplication", however, it is intended.
         */
        uint256 EBTCDebtNumerator = (_debt * DECIMAL_PRECISION) + lastEBTCDebtErrorRedistribution;

        // Get the per-unit-staked terms
        uint256 _totalStakes = totalStakes;
        uint256 EBTCDebtRewardPerUnitStaked = EBTCDebtNumerator / _totalStakes;

        lastEBTCDebtErrorRedistribution =
            EBTCDebtNumerator -
            (EBTCDebtRewardPerUnitStaked * _totalStakes);

        // Add per-unit-staked terms to the running totals
        systemDebtRedistributionIndex = systemDebtRedistributionIndex + EBTCDebtRewardPerUnitStaked;

        emit SystemDebtRedistributionIndexUpdated(systemDebtRedistributionIndex);
    }

    // --- 'require' wrapper functions ---

    function _requirePartialLiqDebtSize(
        uint256 _partialDebt,
        uint256 _entireDebt,
        uint256 _price
    ) internal view {
        require(
            (_partialDebt + _convertDebtDenominationToBtc(MIN_NET_COLL, _price)) <= _entireDebt,
            "LiquidationLibrary: Partial debt liquidated must be less than total debt"
        );
    }

    function _requirePartialLiqCollSize(uint256 _entireColl) internal pure {
        require(
            _entireColl >= MIN_NET_COLL,
            "LiquidationLibrary: Coll remaining in partially liquidated CDP must be >= minimum"
        );
    }
}


Lines covered:	41 / 46 (89.1%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./Interfaces/IPriceFeed.sol";
import "./Interfaces/ICdpManager.sol";
import "./Interfaces/ISortedCdps.sol";
import "./Interfaces/ICdpManagerData.sol";
import "./Dependencies/LiquityBase.sol";

/// @notice Helper to turn a sequence into CDP id array for batch liquidation
/// @dev Note this sequencer only serves as an approximation tool to provide "best-effort"
/// @dev that return a list of CDP ids which could be consumed by "CdpManager.batchLiquidateCdps()".
/// @dev It is possible that some of the returned CDPs might be skipped (not liquidatable any more)
/// @dev during liquidation execution due to change of the system states
/// @dev e.g., TCR brought back from Recovery Mode to Normal Mode
contract LiquidationSequencer is LiquityBase {
    ICdpManager public immutable cdpManager;
    ISortedCdps public immutable sortedCdps;

    constructor(
        address _cdpManagerAddress,
        address _sortedCdpsAddress,
        address _priceFeedAddress,
        address _activePoolAddress,
        address _collateralAddress
    ) LiquityBase(_activePoolAddress, _priceFeedAddress, _collateralAddress) {
        cdpManager = ICdpManager(_cdpManagerAddress);
        sortedCdps = ISortedCdps(_sortedCdpsAddress);
    }

    /// @dev Get first N batch of liquidatable Cdps at current price
    /// @dev Non-view function that updates and returns live price at execution time
    /// @dev could use callStatic offline to save gas
    function sequenceLiqToBatchLiq(uint256 _n) external returns (bytes32[] memory _array) {
        uint256 _price = priceFeed.fetchPrice();
        return sequenceLiqToBatchLiqWithPrice(_n, _price);
    }

    /// @dev Get first N batch of liquidatable Cdps at specified price
    /// @dev Non-view function that will sync global state
    /// @dev could use callStatic offline to save gas
    function sequenceLiqToBatchLiqWithPrice(
        uint256 _n,
        uint256 _price
    ) public returns (bytes32[] memory _array) {
        cdpManager.syncGlobalAccountingAndGracePeriod();
        (uint256 _TCR, , ) = _getTCRWithSystemDebtAndCollShares(_price);
        return _sequenceLiqToBatchLiq(_n, _price, _TCR);
    }

    // return CdpId array (in NICR-decreasing order same as SortedCdps)
    // including the last N CDPs in sortedCdps for batch liquidation
    function _sequenceLiqToBatchLiq(
        uint256 _n,
        uint256 _price,
        uint256 _TCR
    ) internal view returns (bytes32[] memory _array) {
        if (_n > 0) {
            bool _recoveryMode = _TCR < CCR ? true : false;
            // get count of liquidatable CDPs with 1st iteration
            (uint256 _cnt, ) = _iterateOverSortedCdps(0, _TCR, _n, _price, _recoveryMode);

            // retrieve liquidatable CDPs with 2nd iteration
            (uint256 _j, bytes32[] memory _returnedArray) = _iterateOverSortedCdps(
                _cnt,
                _TCR,
                _n,
                _price,
                _recoveryMode
            );
            require(_j == _cnt, "LiquidationSequencer: wrong sequence conversion!");
            _array = _returnedArray;
        }
    }

    function _iterateOverSortedCdps(
        uint256 _realCount,
        uint256 _TCR,
        uint256 _n,
        uint256 _price,
        bool _recoveryMode
    ) internal view returns (uint256 _cnt, bytes32[] memory _array) {
        // if there is already a count (calculated from previous iteration)
        // we use the value to initialize CDP id array for return
        if (_realCount > 0) {
            _array = new bytes32[](_realCount);
        }

        // initialize variables for this iteration
        bytes32 _last = sortedCdps.getLast();
        bytes32 _first = sortedCdps.getFirst();
        bytes32 _cdpId = _last;

        for (uint256 i = 0; i < (_realCount > 0 ? _realCount : _n) && _cdpId != _first; ) {
            bool _liquidatable = _checkCdpLiquidability(_cdpId, _TCR, _price, _recoveryMode);
            if (_liquidatable) {
                if (_realCount > 0) {
                    _array[_realCount - _cnt - 1] = _cdpId;
                }
                unchecked {
                    ++_cnt;
                }
                _cdpId = sortedCdps.getPrev(_cdpId);
            } else {
                // breaking loop early if not liquidatable due to sorted (descending) list of CDPs
                break;
            }
            unchecked {
                ++i;
            }
        }
    }

    function _checkCdpLiquidability(
        bytes32 _cdpId,
        uint256 _TCR,
        uint256 _price,
        bool _recoveryMode
    ) internal view returns (bool) {
        uint256 _icr = cdpManager.getSyncedICR(_cdpId, _price);
        bool _liquidatable = _canLiquidateInCurrentMode(_recoveryMode, _icr, _TCR);
        return _liquidatable;
    }

    function _canLiquidateInCurrentMode(
        bool _recovery,
        uint256 _icr,
        uint256 _TCR
    ) internal view returns (bool) {
        bool _liquidatable = _recovery ? (_icr < MCR || _icr < _TCR) : _icr < MCR;

        return _liquidatable;
    }
}


Lines covered:	170 / 226 (75.2%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./Interfaces/ISortedCdps.sol";
import "./Interfaces/ICdpManager.sol";
import "./Interfaces/IBorrowerOperations.sol";

/*
 * A sorted doubly linked list with nodes sorted in descending order.
 *
 * Nodes map to active Cdps in the system by ID.
 * Nodes are ordered according to their current nominal individual collateral ratio (NICR),
 * which is like the ICR but without the price, i.e., just collateral / debt.
 *
 * The list optionally accepts insert position hints.
 *
 * NICRs are computed dynamically at runtime, and not stored on the Node. This is because NICRs of active Cdps
 * change dynamically as liquidation events occur.
 *
 * The list relies on the fact that liquidation events preserve ordering: a liquidation decreases the NICRs of all active Cdps,
 * but maintains their order. A node inserted based on current NICR will maintain the correct position,
 * relative to it's peers, as rewards accumulate, as long as it's raw collateral and debt have not changed.
 * Thus, Nodes remain sorted by current NICR.
 *
 * Nodes need only be re-inserted upon a Cdp operation - when the owner adds or removes collateral or debt
 * to their position.
 *
 * The list is a modification of the following audited SortedDoublyLinkedList:
 * https://github.com/livepeer/protocol/blob/master/contracts/libraries/SortedDoublyLL.sol
 *
 *
 * Changes made in the Liquity implementation:
 *
 * - Keys have been removed from nodes
 *
 * - Ordering checks for insertion are performed by comparing an NICR argument to the current NICR, calculated at runtime.
 *   The list relies on the property that ordering by ICR is maintained as the stETH:BTC price varies.
 *
 * - Public functions with parameters have been made internal to save gas, and given an external wrapper function for external access
 */
contract SortedCdps is ISortedCdps {
    string public constant NAME = "SortedCdps";

    address public immutable borrowerOperationsAddress;

    ICdpManager public immutable cdpManager;

    uint256 public immutable maxSize;

    uint256 constant ADDRESS_SHIFT = 96; // 8 * 12; Puts the address at leftmost bytes32 position
    uint256 constant BLOCK_SHIFT = 64; // 8 * 8; Puts the block value after the address

    // Information for a node in the list
    struct Node {
        bytes32 nextId; // Id of next node (smaller NICR) in the list
        bytes32 prevId; // Id of previous node (larger NICR) in the list
    }

    // Information for the list
    struct Data {
        bytes32 head; // Head of the list. Also the node in the list with the largest NICR
        bytes32 tail; // Tail of the list. Also the node in the list with the smallest NICR
        uint256 size; // Current size of the list
        mapping(bytes32 => Node) nodes; // Track the corresponding ids for each node in the list
    }

    Data public data;

    uint256 public nextCdpNonce;
    bytes32 public constant dummyId =
        0x0000000000000000000000000000000000000000000000000000000000000000;

    // --- Dependency setters ---
    constructor(uint256 _size, address _cdpManagerAddress, address _borrowerOperationsAddress) {
        if (_size == 0) {
            _size = type(uint256).max;
        }

        maxSize = _size;

        cdpManager = ICdpManager(_cdpManagerAddress);
        borrowerOperationsAddress = _borrowerOperationsAddress;
    }

    // https://github.com/balancer-labs/balancer-v2-monorepo/blob/18bd5fb5d87b451cc27fbd30b276d1fb2987b529/pkg/vault/contracts/PoolRegistry.sol
    function toCdpId(
        address owner,
        uint256 blockHeight,
        uint256 nonce
    ) public pure returns (bytes32) {
        bytes32 serialized;

        serialized |= bytes32(nonce);
        serialized |= bytes32(blockHeight) << BLOCK_SHIFT; // to accommendate more than 4.2 billion blocks
        serialized |= bytes32(uint256(uint160(owner))) << ADDRESS_SHIFT;

        return serialized;
    }

    /// @notice Get owner address of a given Cdp, by CdpId.
    /// @dev The owner address is stored in the first 20 bytes of the CdpId
    /// @param cdpId cdpId of Cdp to get owner of
    /// @return owner address of the Cdp
    function getOwnerAddress(bytes32 cdpId) public pure override returns (address) {
        uint256 _tmp = uint256(cdpId) >> ADDRESS_SHIFT;
        return address(uint160(_tmp));
    }

    function nonExistId() public pure override returns (bytes32) {
        return dummyId;
    }

    /// @notice Find a specific Cdp for a given owner, indexed by it's place in the linked list relative to other Cdps owned by the same address
    /// @notice Reverts if the index exceeds the number of active Cdps owned by the given owner
    /// @dev Intended for off-chain use, O(n) operation on size of SortedCdps linked list
    /// @param owner address of Cdp owner
    /// @param index index of Cdp, ordered by position in linked list relative to Cdps of the same owner
    function cdpOfOwnerByIndex(
        address owner,
        uint256 index
    ) external view override returns (bytes32) {
        (bytes32 _cdpId, ) = _cdpOfOwnerByIndex(owner, index, dummyId, 0);
        return _cdpId;
    }

    /// @dev a pagination-flavor search (from least ICR to biggest ICR) for CDP owned by given owner and specified index (starting at given CDP)
    /// @param startNodeId the seach traversal will start at this given CDP instead of the tail of the list
    /// @param maxNodes the traversal will go through the list by this given maximum limit of number of CDPs
    function cdpOfOwnerByIdx(
        address owner,
        uint256 index,
        bytes32 startNodeId,
        uint maxNodes
    ) external view override returns (bytes32, bool) {
        return _cdpOfOwnerByIndex(owner, index, startNodeId, maxNodes);
    }

    /// @dev return EITHER the found CDP owned by given owner & index with a true indicator OR
    /// @dev        current lastly-visited CDP as the startNode for next pagination with a false indicator
    function _cdpOfOwnerByIndex(
        address owner,
        uint256 index,
        bytes32 startNodeId,
        uint maxNodes
    ) internal view returns (bytes32, bool) {
        // walk the list, until we get to the indexed CDP
        // start at the given node or from the tail of list
        bytes32 _currentCdpId = (startNodeId == dummyId ? data.tail : startNodeId);
        uint _currentIndex = 0;
        uint i;

        while (_currentCdpId != dummyId) {
            // if the current Cdp is owned by specified owner
            if (getOwnerAddress(_currentCdpId) == owner) {
                // if the current index of the owner Cdp matches specified index
                if (_currentIndex == index) {
                    return (_currentCdpId, true);
                } else {
                    // if not, increment the owner index as we've seen a Cdp owned by them
                    _currentIndex = _currentIndex + 1;
                }
            }
            ++i;

            // move to the next Cdp in the list
            _currentCdpId = data.nodes[_currentCdpId].prevId;

            // cut the run if we exceed expected iterations through the loop
            if (maxNodes > 0 && i >= maxNodes) {
                break;
            }
        }
        // if we reach maximum iteration or end of list
        // without seeing the specified index for the owner
        // then maybe a new pagination is needed
        return (_currentCdpId, false);
    }

    /// @notice Get active Cdp count of a given address
    /// @dev Intended for off-chain use, O(n) operation on size of linked list
    function cdpCountOf(address owner) external view override returns (uint256) {
        (uint256 _cnt, ) = _cdpCountOf(owner, dummyId, 0);
        return _cnt;
    }

    /// @dev a pagination-flavor search count of (from least ICR to biggest ICR) CDPs owned by given owner (starting at given CDP)
    /// @param startNodeId the count traversal will start at this given CDP instead of the tail of the list
    /// @param maxNodes the traversal will go through the list by this given maximum limit of number of CDPs
    function getCdpCountOf(
        address owner,
        bytes32 startNodeId,
        uint maxNodes
    ) external view override returns (uint256, bytes32) {
        return _cdpCountOf(owner, startNodeId, maxNodes);
    }

    /// @dev return the found CDP count owned by given owner with
    /// @dev        current lastly-visited CDP as the startNode for next pagination
    function _cdpCountOf(
        address owner,
        bytes32 startNodeId,
        uint maxNodes
    ) internal view returns (uint256, bytes32) {
        // walk the list, until we get to the count
        // start at the given node or from the tail of list
        bytes32 _currentCdpId = (startNodeId == dummyId ? data.tail : startNodeId);
        uint _ownedCount = 0;
        uint i = 0;

        while (_currentCdpId != dummyId) {
            // if the current Cdp is owned by specified owner
            if (getOwnerAddress(_currentCdpId) == owner) {
                _ownedCount = _ownedCount + 1;
            }
            ++i;

            // move to the next Cdp in the list
            _currentCdpId = data.nodes[_currentCdpId].prevId;

            // cut the run if we exceed expected iterations through the loop
            if (maxNodes > 0 && i >= maxNodes) {
                break;
            }
        }
        return (_ownedCount, _currentCdpId);
    }

    /// @notice Get all active Cdps for a given address
    /// @dev Intended for off-chain use, O(n) operation on size of linked list
    function getCdpsOf(address owner) external view override returns (bytes32[] memory cdps) {
        // Naive method uses two-pass strategy to determine exactly how many Cdps are owned by owner
        // This roughly halves the amount of Cdps we can process before relying on pagination or off-chain methods
        (uint _ownedCount, ) = _cdpCountOf(owner, dummyId, 0);
        if (_ownedCount > 0) {
            (bytes32[] memory _allCdps, , ) = _getCdpsOf(owner, dummyId, 0, _ownedCount);
            cdps = _allCdps;
        }
    }

    /// @dev a pagination-flavor search retrieval of (from least ICR to biggest ICR) CDPs owned by given owner (starting at given CDP)
    /// @param startNodeId the traversal will start at this given CDP instead of the tail of the list
    /// @param maxNodes the traversal will go through the list by this given maximum limit of number of CDPs
    function getAllCdpsOf(
        address owner,
        bytes32 startNodeId,
        uint maxNodes
    ) external view override returns (bytes32[] memory, uint256, bytes32) {
        // Naive method uses two-pass strategy to determine exactly how many Cdps are owned by owner
        // This roughly halves the amount of Cdps we can process before relying on pagination or off-chain methods
        (uint _ownedCount, ) = _cdpCountOf(owner, startNodeId, maxNodes);
        return _getCdpsOf(owner, startNodeId, maxNodes, _ownedCount);
    }

    /// @dev return EITHER the found CDPs (also the count) owned by given owner OR empty array with
    /// @dev        current lastly-visited CDP as the startNode for next pagination
    function _getCdpsOf(
        address owner,
        bytes32 startNodeId,
        uint maxNodes,
        uint maxArraySize
    ) internal view returns (bytes32[] memory, uint256, bytes32) {
        if (maxArraySize == 0) {
            return (new bytes32[](0), 0, dummyId);
        }

        // Two-pass strategy, halving the amount of Cdps we can process before relying on pagination or off-chain methods
        bytes32[] memory userCdps = new bytes32[](maxArraySize);
        uint i = 0;
        uint _cdpRetrieved;

        // walk the list, until we get to the index
        // start at the given node or from the tail of list
        bytes32 _currentCdpId = (startNodeId == dummyId ? data.tail : startNodeId);

        while (_currentCdpId != dummyId) {
            // if the current Cdp is owned by specified owner
            if (getOwnerAddress(_currentCdpId) == owner) {
                userCdps[_cdpRetrieved] = _currentCdpId;
                ++_cdpRetrieved;
            }
            ++i;

            // move to the next Cdp in the list
            _currentCdpId = data.nodes[_currentCdpId].prevId;

            // cut the run if we exceed expected iterations through the loop
            if (maxNodes > 0 && i >= maxNodes) {
                break;
            }
        }

        return (userCdps, _cdpRetrieved, _currentCdpId);
    }

    /*
     * @dev Add a node to the list
     * @param owner cdp owner
     * @param _NICR Node's NICR
     * @param _prevId Id of previous node for the insert position
     * @param _nextId Id of next node for the insert position
     */
    function insert(
        address owner,
        uint256 _NICR,
        bytes32 _prevId,
        bytes32 _nextId
    ) external override returns (bytes32) {
        _requireCallerIsBOorCdpM();
        bytes32 _id = toCdpId(owner, block.number, nextCdpNonce);
        require(cdpManager.getCdpStatus(_id) == 0, "SortedCdps: new id is NOT nonExistent!");

        _insert(_id, _NICR, _prevId, _nextId);

        unchecked {
            ++nextCdpNonce;
        }

        return _id;
    }

    function _insert(bytes32 _id, uint256 _NICR, bytes32 _prevId, bytes32 _nextId) internal {
        // List must not be full
        require(!isFull(), "SortedCdps: List is full");
        // List must not already contain node
        require(!contains(_id), "SortedCdps: List already contains the node");
        // Node id must not be null
        require(_id != dummyId, "SortedCdps: Id cannot be zero");
        // NICR must be non-zero
        require(_NICR > 0, "SortedCdps: NICR must be positive");

        bytes32 prevId = _prevId;
        bytes32 nextId = _nextId;

        if (!_validInsertPosition(_NICR, prevId, nextId)) {
            // Sender's hint was not a valid insert position
            // Use sender's hint to find a valid insert position
            (prevId, nextId) = _findInsertPosition(_NICR, prevId, nextId);
        }

        if (prevId == dummyId && nextId == dummyId) {
            // Insert as head and tail
            data.head = _id;
            data.tail = _id;
        } else if (prevId == dummyId) {
            // Insert before `prevId` as the head
            data.nodes[_id].nextId = data.head;
            data.nodes[data.head].prevId = _id;
            data.head = _id;
        } else if (nextId == dummyId) {
            // Insert after `nextId` as the tail
            data.nodes[_id].prevId = data.tail;
            data.nodes[data.tail].nextId = _id;
            data.tail = _id;
        } else {
            // Insert at insert position between `prevId` and `nextId`
            data.nodes[_id].nextId = nextId;
            data.nodes[_id].prevId = prevId;
            data.nodes[prevId].nextId = _id;
            data.nodes[nextId].prevId = _id;
        }

        data.size = data.size + 1;
        emit NodeAdded(_id, _NICR);
    }

    function remove(bytes32 _id) external override {
        _requireCallerIsCdpManager();
        _remove(_id);
    }

    function batchRemove(bytes32[] memory _ids) external override {
        _requireCallerIsCdpManager();
        uint256 _len = _ids.length;
        require(_len > 1, "SortedCdps: batchRemove() only apply to multiple cdpIds!");

        bytes32 _firstPrev = data.nodes[_ids[0]].prevId;
        bytes32 _lastNext = data.nodes[_ids[_len - 1]].nextId;

        require(
            _firstPrev != dummyId || _lastNext != dummyId,
            "SortedCdps: batchRemove() leave ZERO node left!"
        );

        for (uint256 i = 0; i < _len; ++i) {
            require(contains(_ids[i]), "SortedCdps: List does not contain the id");
        }

        // orphan nodes in between to save gas
        if (_firstPrev != dummyId) {
            data.nodes[_firstPrev].nextId = _lastNext;
        } else {
            data.head = _lastNext;
        }
        if (_lastNext != dummyId) {
            data.nodes[_lastNext].prevId = _firstPrev;
        } else {
            data.tail = _firstPrev;
        }

        // delete node & owner storages to get gas refund
        for (uint i = 0; i < _len; ++i) {
            delete data.nodes[_ids[i]];
            emit NodeRemoved(_ids[i]);
        }
        data.size = data.size - _len;
    }

    /*
     * @dev Remove a node from the list
     * @param _id Node's id
     */
    function _remove(bytes32 _id) internal {
        // List must contain the node
        require(contains(_id), "SortedCdps: List does not contain the id");

        if (data.size > 1) {
            // List contains more than a single node
            if (_id == data.head) {
                // The removed node is the head
                // Set head to next node
                data.head = data.nodes[_id].nextId;
                // Set prev pointer of new head to null
                data.nodes[data.head].prevId = dummyId;
            } else if (_id == data.tail) {
                // The removed node is the tail
                // Set tail to previous node
                data.tail = data.nodes[_id].prevId;
                // Set next pointer of new tail to null
                data.nodes[data.tail].nextId = dummyId;
            } else {
                // The removed node is neither the head nor the tail
                // Set next pointer of previous node to the next node
                data.nodes[data.nodes[_id].prevId].nextId = data.nodes[_id].nextId;
                // Set prev pointer of next node to the previous node
                data.nodes[data.nodes[_id].nextId].prevId = data.nodes[_id].prevId;
            }
        } else {
            // List contains a single node
            // Set the head and tail to null
            data.head = dummyId;
            data.tail = dummyId;
        }

        delete data.nodes[_id];
        data.size = data.size - 1;
        emit NodeRemoved(_id);
    }

    /*
     * @dev Re-insert the node at a new position, based on its new NICR
     * @param _id Node's id
     * @param _newNICR Node's new NICR
     * @param _prevId Id of previous node for the new insert position
     * @param _nextId Id of next node for the new insert position
     */
    function reInsert(
        bytes32 _id,
        uint256 _newNICR,
        bytes32 _prevId,
        bytes32 _nextId
    ) external override {
        _requireCallerIsBOorCdpM();
        // List must contain the node
        require(contains(_id), "SortedCdps: List does not contain the id");
        // NICR must be non-zero
        require(_newNICR > 0, "SortedCdps: NICR must be positive");

        // Remove node from the list
        _remove(_id);

        _insert(_id, _newNICR, _prevId, _nextId);
    }

    /**
     * @dev Checks if the list contains a given node
     * @param _id The ID of the node
     * @return true if the node exists, false otherwise
     */
    function contains(bytes32 _id) public view override returns (bool) {
        bool _exist = _id != dummyId && (data.head == _id || data.tail == _id);
        if (!_exist) {
            Node memory _node = data.nodes[_id];
            _exist = _id != dummyId && (_node.nextId != dummyId && _node.prevId != dummyId);
        }
        return _exist;
    }

    /**
     * @dev Checks if the list is full
     * @return true if the list is full, false otherwise
     */
    function isFull() public view override returns (bool) {
        return data.size == maxSize;
    }

    /**
     * @dev Checks if the list is empty
     * @return true if the list is empty, false otherwise
     */
    function isEmpty() public view override returns (bool) {
        return data.size == 0;
    }

    /**
     * @dev Returns the current size of the list
     * @return The current size of the list
     */
    function getSize() external view override returns (uint256) {
        return data.size;
    }

    /**
     * @dev Returns the maximum size of the list
     * @return The maximum size of the list
     */
    function getMaxSize() external view override returns (uint256) {
        return maxSize;
    }

    /**
     * @dev Returns the first node in the list (node with the largest NICR)
     * @return The ID of the first node
     */
    function getFirst() external view override returns (bytes32) {
        return data.head;
    }

    /**
     * @dev Returns the last node in the list (node with the smallest NICR)
     * @return The ID of the last node
     */
    function getLast() external view override returns (bytes32) {
        return data.tail;
    }

    /**
     * @dev Returns the next node (with a smaller NICR) in the list for a given node
     * @param _id The ID of the node
     * @return The ID of the next node
     */
    function getNext(bytes32 _id) external view override returns (bytes32) {
        return data.nodes[_id].nextId;
    }

    /**
     * @dev Returns the previous node (with a larger NICR) in the list for a given node
     * @param _id The ID of the node
     * @return The ID of the previous node
     */
    function getPrev(bytes32 _id) external view override returns (bytes32) {
        return data.nodes[_id].prevId;
    }

    /*
     * @dev Check if a pair of nodes is a valid insertion point for a new node with the given NICR
     * @param _NICR Node's NICR
     * @param _prevId Id of previous node for the insert position
     * @param _nextId Id of next node for the insert position
     * @return true if the position is valid, false otherwise
     */
    function validInsertPosition(
        uint256 _NICR,
        bytes32 _prevId,
        bytes32 _nextId
    ) external view override returns (bool) {
        return _validInsertPosition(_NICR, _prevId, _nextId);
    }

    function _validInsertPosition(
        uint256 _NICR,
        bytes32 _prevId,
        bytes32 _nextId
    ) internal view returns (bool) {
        if (_prevId == dummyId && _nextId == dummyId) {
            // `(null, null)` is a valid insert position if the list is empty
            return isEmpty();
        } else if (_prevId == dummyId) {
            // `(null, _nextId)` is a valid insert position if `_nextId` is the head of the list
            return data.head == _nextId && _NICR >= cdpManager.getNominalICR(_nextId);
        } else if (_nextId == dummyId) {
            // `(_prevId, null)` is a valid insert position if `_prevId` is the tail of the list
            return data.tail == _prevId && _NICR <= cdpManager.getNominalICR(_prevId);
        } else {
            // `(_prevId, _nextId)` is a valid insert position if they are adjacent nodes and `_NICR` falls between the two nodes' NICRs
            return
                data.nodes[_prevId].nextId == _nextId &&
                cdpManager.getNominalICR(_prevId) >= _NICR &&
                _NICR >= cdpManager.getNominalICR(_nextId);
        }
    }

    /*
     * @dev Descend the list (larger NICRs to smaller NICRs) to find a valid insert position
     * @param _NICR Node's NICR
     * @param _startId Id of node to start descending the list from
     */
    function _descendList(uint256 _NICR, bytes32 _startId) internal view returns (bytes32, bytes32) {
        // If `_startId` is the head, check if the insert position is before the head
        if (data.head == _startId && _NICR >= cdpManager.getNominalICR(_startId)) {
            return (dummyId, _startId);
        }

        bytes32 prevId = _startId;
        bytes32 nextId = data.nodes[prevId].nextId;

        // Descend the list until we reach the end or until we find a valid insert position
        while (prevId != dummyId && !_validInsertPosition(_NICR, prevId, nextId)) {
            prevId = data.nodes[prevId].nextId;
            nextId = data.nodes[prevId].nextId;
        }

        return (prevId, nextId);
    }

    /*
     * @dev Ascend the list (smaller NICRs to larger NICRs) to find a valid insert position
     * @param _NICR Node's NICR
     * @param _startId Id of node to start ascending the list from
     */
    function _ascendList(uint256 _NICR, bytes32 _startId) internal view returns (bytes32, bytes32) {
        // If `_startId` is the tail, check if the insert position is after the tail
        if (data.tail == _startId && _NICR <= cdpManager.getNominalICR(_startId)) {
            return (_startId, dummyId);
        }

        bytes32 nextId = _startId;
        bytes32 prevId = data.nodes[nextId].prevId;

        // Ascend the list until we reach the end or until we find a valid insertion point
        while (nextId != dummyId && !_validInsertPosition(_NICR, prevId, nextId)) {
            nextId = data.nodes[nextId].prevId;
            prevId = data.nodes[nextId].prevId;
        }

        return (prevId, nextId);
    }

    /*
     * @dev Find the insert position for a new node with the given NICR
     * @param _NICR Node's NICR
     * @param _prevId Id of previous node for the insert position
     * @param _nextId Id of next node for the insert position
     * @return The IDs of the previous and next nodes for the insert position
     */
    function findInsertPosition(
        uint256 _NICR,
        bytes32 _prevId,
        bytes32 _nextId
    ) external view override returns (bytes32, bytes32) {
        return _findInsertPosition(_NICR, _prevId, _nextId);
    }

    function _findInsertPosition(
        uint256 _NICR,
        bytes32 _prevId,
        bytes32 _nextId
    ) internal view returns (bytes32, bytes32) {
        bytes32 prevId = _prevId;
        bytes32 nextId = _nextId;

        if (prevId != dummyId) {
            if (!contains(prevId) || _NICR > cdpManager.getNominalICR(prevId)) {
                // `prevId` does not exist anymore or now has a smaller NICR than the given NICR
                prevId = dummyId;
            }
        }

        if (nextId != dummyId) {
            if (!contains(nextId) || _NICR < cdpManager.getNominalICR(nextId)) {
                // `nextId` does not exist anymore or now has a larger NICR than the given NICR
                nextId = dummyId;
            }
        }

        if (prevId == dummyId && nextId == dummyId) {
            // No hint - descend list starting from head
            return _descendList(_NICR, data.head);
        } else if (prevId == dummyId) {
            // No `prevId` for hint - ascend list starting from `nextId`
            return _ascendList(_NICR, nextId);
        } else if (nextId == dummyId) {
            // No `nextId` for hint - descend list starting from `prevId`
            return _descendList(_NICR, prevId);
        } else {
            // Descend list starting from `prevId`
            return _descendList(_NICR, prevId);
        }
    }

    // --- 'require' functions ---

    /// @dev Asserts that the caller of the function is the CdpManager
    function _requireCallerIsCdpManager() internal view {
        require(msg.sender == address(cdpManager), "SortedCdps: Caller is not the CdpManager");
    }

    /// @dev Asserts that the caller of the function is either the BorrowerOperations contract or the CdpManager
    function _requireCallerIsBOorCdpM() internal view {
        require(
            msg.sender == borrowerOperationsAddress || msg.sender == address(cdpManager),
            "SortedCdps: Caller is neither BO nor CdpM"
        );
    }
}


Lines covered:	36 / 41 (87.8%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./Interfaces/IPriceFeed.sol";
import "./Interfaces/ICdpManager.sol";
import "./Interfaces/ISortedCdps.sol";
import "./Interfaces/ICdpManagerData.sol";
import "./Dependencies/LiquityBase.sol";

/// @notice Helper to turn a sequence into CDP id array for batch liquidation
contract SyncedLiquidationSequencer is LiquityBase {
    ICdpManager public immutable cdpManager;
    ISortedCdps public immutable sortedCdps;

    constructor(
        address _cdpManagerAddress,
        address _sortedCdpsAddress,
        address _priceFeedAddress,
        address _activePoolAddress,
        address _collateralAddress
    ) LiquityBase(_activePoolAddress, _priceFeedAddress, _collateralAddress) {
        cdpManager = ICdpManager(_cdpManagerAddress);
        sortedCdps = ISortedCdps(_sortedCdpsAddress);
    }

    /// @dev Get first N batch of liquidatable Cdps at current price
    /// @dev Non-view function that updates and returns live price at execution time
    function sequenceLiqToBatchLiq(uint256 _n) external returns (bytes32[] memory _array) {
        uint256 _price = priceFeed.fetchPrice();
        return sequenceLiqToBatchLiqWithPrice(_n, _price);
    }

    /// @dev Get first N batch of liquidatable Cdps at specified price
    function sequenceLiqToBatchLiqWithPrice(
        uint256 _n,
        uint256 _price
    ) public view returns (bytes32[] memory _array) {
        (uint256 _TCR, , ) = _getTCRWithSystemDebtAndCollShares(_price);
        bool _recoveryModeAtStart = _TCR < CCR ? true : false;
        return _sequenceLiqToBatchLiq(_n, _recoveryModeAtStart, _price);
    }

    // return CdpId array (in NICR-decreasing order same as SortedCdps)
    // including the last N CDPs in sortedCdps for batch liquidation
    function _sequenceLiqToBatchLiq(
        uint256 _n,
        bool _recoveryModeAtStart,
        uint256 _price
    ) internal view returns (bytes32[] memory _array) {
        if (_n > 0) {
            bytes32 _last = sortedCdps.getLast();
            bytes32 _first = sortedCdps.getFirst();
            bytes32 _cdpId = _last;

            uint256 _TCR = cdpManager.getSyncedTCR(_price);

            // get count of liquidatable CDPs
            uint256 _cnt;
            for (uint256 i = 0; i < _n && _cdpId != _first; ++i) {
                uint256 _icr = cdpManager.getSyncedICR(_cdpId, _price); /// @audit This is view ICR and not real ICR
                uint256 _cdpStatus = cdpManager.getCdpStatus(_cdpId);
                bool _liquidatable = _canLiquidateInCurrentMode(_recoveryModeAtStart, _icr, _TCR);
                if (_liquidatable && _cdpStatus == 1) {
                    _cnt += 1;
                }
                _cdpId = sortedCdps.getPrev(_cdpId);
            }

            // retrieve liquidatable CDPs
            _array = new bytes32[](_cnt);
            _cdpId = _last;
            uint256 _j;
            for (uint256 i = 0; i < _n && _cdpId != _first; ++i) {
                uint256 _icr = cdpManager.getSyncedICR(_cdpId, _price);
                uint256 _cdpStatus = cdpManager.getCdpStatus(_cdpId);
                bool _liquidatable = _canLiquidateInCurrentMode(_recoveryModeAtStart, _icr, _TCR);
                if (_liquidatable && _cdpStatus == 1) {
                    // 1 = ICdpManagerData.Status.active
                    _array[_cnt - _j - 1] = _cdpId;
                    _j += 1;
                }
                _cdpId = sortedCdps.getPrev(_cdpId);
            }
            require(_j == _cnt, "LiquidationLibrary: wrong sequence conversion!");
        }
    }

    function _canLiquidateInCurrentMode(
        bool _recovery,
        uint256 _icr,
        uint256 _TCR
    ) internal view returns (bool) {
        bool _liquidatable = _recovery ? (_icr < MCR || _icr < _TCR) : _icr < MCR;

        return _liquidatable;
    }
}


Lines covered:	6 / 6 (100.0%)

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.17;

import {WETH9} from "./WETH9.sol";
import {BorrowerOperations} from "../BorrowerOperations.sol";
import {PriceFeedTestnet} from "./testnet/PriceFeedTestnet.sol";
import {SortedCdps} from "../SortedCdps.sol";
import {CdpManager} from "../CdpManager.sol";
import {LiquidationLibrary} from "../LiquidationLibrary.sol";
import {LiquidationSequencer} from "../LiquidationSequencer.sol";
import {SyncedLiquidationSequencer} from "../SyncedLiquidationSequencer.sol";
import {ActivePool} from "../ActivePool.sol";
import {HintHelpers} from "../HintHelpers.sol";
import {FeeRecipient} from "../FeeRecipient.sol";
import {EBTCToken} from "../EBTCToken.sol";
import {CollSurplusPool} from "../CollSurplusPool.sol";
import {FunctionCaller} from "./FunctionCaller.sol";
import {CollateralTokenTester} from "./CollateralTokenTester.sol";
import {Governor} from "../Governor.sol";
import {EBTCDeployer} from "../EBTCDeployer.sol";
import {Actor} from "./invariants/Actor.sol";
import {CRLens} from "../CRLens.sol";

abstract contract BaseStorageVariables {
    PriceFeedTestnet internal priceFeedMock;
    SortedCdps internal sortedCdps;
    CdpManager internal cdpManager;
    WETH9 internal weth;
    ActivePool internal activePool;
    CollSurplusPool internal collSurplusPool;
    FunctionCaller internal functionCaller;
    BorrowerOperations internal borrowerOperations;
    HintHelpers internal hintHelpers;
    EBTCToken internal eBTCToken;
    CollateralTokenTester internal collateral;
    Governor internal authority;
    LiquidationLibrary internal liqudationLibrary;
    LiquidationSequencer internal liquidationSequencer;
    SyncedLiquidationSequencer internal syncedLiquidationSequencer;
    EBTCDeployer internal ebtcDeployer;
    address internal defaultGovernance;

    // LQTY Stuff
    FeeRecipient internal feeRecipient;

    mapping(address => Actor) internal actors;
    Actor internal actor;

    CRLens internal crLens;

    uint internal constant NUMBER_OF_ACTORS = 3;
    uint internal constant INITIAL_ETH_BALANCE = 1e24;
    uint internal constant INITIAL_COLL_BALANCE = 1e21;

    uint internal constant diff_tolerance = 0.000000000002e18; //compared to 1e18
    uint internal constant MAX_PRICE_CHANGE_PERCENT = 1.05e18; //compared to 1e18
    uint internal constant MAX_REBASE_PERCENT = 1.1e18; //compared to 1e18
    uint internal constant MAX_FLASHLOAN_ACTIONS = 4;
}


Lines covered:	56 / 113 (49.6%)

// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

import "../Dependencies/ICollateralToken.sol";
import "../Dependencies/ICollateralTokenOracle.sol";
import "../Dependencies/Ownable.sol";

interface IEbtcInternalPool {
    function increaseSystemCollShares(uint256 _value) external;
}

// based on WETH9 contract
contract CollateralTokenTester is ICollateralToken, ICollateralTokenOracle, Ownable {
    string public override name = "Collateral Token Tester in eBTC";
    string public override symbol = "CollTester";
    uint8 public override decimals = 18;

    event Transfer(address indexed src, address indexed dst, uint256 wad, uint256 _share);
    event Deposit(address indexed dst, uint256 wad, uint256 _share);
    event Withdrawal(address indexed src, uint256 wad, uint256 _share);
    event UncappedMinterAdded(address indexed account);
    event UncappedMinterRemoved(address indexed account);
    event MintCapSet(uint256 indexed newCap);
    event MintCooldownSet(uint256 indexed newCooldown);

    mapping(address => uint256) private balances;
    mapping(address => mapping(address => uint256)) public override allowance;
    mapping(address => bool) public isUncappedMinter;
    mapping(address => uint256) public lastMintTime;

    // Faucet capped at 10 Collateral tokens per day
    uint256 public mintCap = 10e18;
    uint256 public mintCooldown = 60 * 60 * 24;

    uint256 private _ethPerShare = 1e18;
    uint256 private _totalBalance;

    uint256 private epochsPerFrame = 225;
    uint256 private slotsPerEpoch = 32;
    uint256 private secondsPerSlot = 12;

    receive() external payable {
        deposit();
    }

    function deposit() public payable {
        uint256 _share = getSharesByPooledEth(msg.value);
        balances[msg.sender] += _share;
        _totalBalance += _share;
        emit Deposit(msg.sender, msg.value, _share);
    }

    /// @dev Deposit collateral without ether for testing purposes
    function forceDeposit(uint256 ethToDeposit) external {
        if (!isUncappedMinter[msg.sender]) {
            require(ethToDeposit <= mintCap, "CollTester: Above mint cap");
            require(
                lastMintTime[msg.sender] == 0 ||
                    lastMintTime[msg.sender] + mintCooldown < block.timestamp,
                "CollTester: Cooldown period not completed"
            );
            lastMintTime[msg.sender] = block.timestamp;
        }
        uint256 _share = getSharesByPooledEth(ethToDeposit);
        balances[msg.sender] += _share;
        _totalBalance += _share;
        emit Deposit(msg.sender, ethToDeposit, _share);
    }

    function withdraw(uint256 wad) public {
        uint256 _share = getSharesByPooledEth(wad);
        require(balances[msg.sender] >= _share);
        balances[msg.sender] -= _share;
        _totalBalance -= _share;
        payable(msg.sender).transfer(wad);
        emit Withdrawal(msg.sender, wad, _share);
    }

    function totalSupply() public view override returns (uint) {
        uint _tmp = _mul(_ethPerShare, _totalBalance);
        return _div(_tmp, 1e18);
    }

    // Permissioned functions
    function addUncappedMinter(address account) external onlyOwner {
        isUncappedMinter[account] = true;
        emit UncappedMinterAdded(account);
    }

    function removeUncappedMinter(address account) external onlyOwner {
        isUncappedMinter[account] = false;
        emit UncappedMinterRemoved(account);
    }

    function setMintCap(uint256 newCap) external onlyOwner {
        mintCap = newCap;
        emit MintCapSet(newCap);
    }

    function setMintCooldown(uint256 newCooldown) external onlyOwner {
        mintCooldown = newCooldown;
        emit MintCooldownSet(newCooldown);
    }

    // helper to set allowance in test
    function nonStandardSetApproval(
        address owner,
        address guy,
        uint256 wad
    ) external returns (bool) {
        allowance[owner][guy] = wad;
        emit Approval(owner, guy, wad);
        return true;
    }

    function approve(address guy, uint256 wad) public override returns (bool) {
        allowance[msg.sender][guy] = wad;
        emit Approval(msg.sender, guy, wad);
        return true;
    }

    function transfer(address dst, uint256 wad) public override returns (bool) {
        return transferFrom(msg.sender, dst, wad);
    }

    function transferFrom(address src, address dst, uint256 wad) public override returns (bool) {
        uint256 _share = getSharesByPooledEth(wad);
        require(balances[src] >= _share, "ERC20: transfer amount exceeds balance");

        if (src != msg.sender && allowance[src][msg.sender] != type(uint256).max) {
            require(allowance[src][msg.sender] >= wad);
            allowance[src][msg.sender] -= wad;
        }

        balances[src] -= _share;
        balances[dst] += _share;

        emit Transfer(src, dst, wad, _share);

        return true;
    }

    // tests should adjust the ratio by this function
    function setEthPerShare(uint256 _ePerS) external {
        _ethPerShare = _ePerS;
    }

    function getEthPerShare() external view returns (uint256) {
        return _ethPerShare;
    }

    function getSharesByPooledEth(uint256 _ethAmount) public view override returns (uint256) {
        uint256 _tmp = _mul(1e18, _ethAmount);
        return _div(_tmp, _ethPerShare);
    }

    function getPooledEthByShares(uint256 _sharesAmount) public view override returns (uint256) {
        uint256 _tmp = _mul(_ethPerShare, _sharesAmount);
        return _div(_tmp, 1e18);
    }

    function transferShares(
        address _recipient,
        uint256 _sharesAmount
    ) public override returns (uint256) {
        uint256 _tknAmt = getPooledEthByShares(_sharesAmount);

        // NOTE: Changed here to transfer underlying shares without rounding
        balances[msg.sender] -= _sharesAmount;
        balances[_recipient] += _sharesAmount;

        emit Transfer(msg.sender, _recipient, _tknAmt, _sharesAmount);

        return _tknAmt;
    }

    function sharesOf(address _account) public view override returns (uint256) {
        return balances[_account];
    }

    function getOracle() external view override returns (address) {
        return address(this);
    }

    function getBeaconSpec() public view override returns (uint64, uint64, uint64, uint64) {
        return (
            uint64(epochsPerFrame),
            uint64(slotsPerEpoch),
            uint64(secondsPerSlot),
            uint64(block.timestamp)
        );
    }

    function setBeaconSpec(
        uint64 _epochsPerFrame,
        uint64 _slotsPerEpoch,
        uint64 _secondsPerSlot
    ) external {
        epochsPerFrame = _epochsPerFrame;
        slotsPerEpoch = _slotsPerEpoch;
        secondsPerSlot = _secondsPerSlot;
    }

    function decreaseAllowance(
        address spender,
        uint256 subtractedValue
    ) external override returns (bool) {
        approve(spender, allowance[msg.sender][spender] - subtractedValue);
        return true;
    }

    function balanceOf(address _usr) external view override returns (uint256) {
        uint256 _tmp = _mul(_ethPerShare, balances[_usr]);
        return _div(_tmp, 1e18);
    }

    function increaseAllowance(
        address spender,
        uint256 addedValue
    ) external override returns (bool) {
        approve(spender, allowance[msg.sender][spender] + addedValue);
        return true;
    }

    // internal helper functions
    function _mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    function _div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: zero denominator");
        uint256 c = a / b;
        return c;
    }

    // dummy test purpose
    function feeRecipientAddress() external view returns (address) {
        return address(this);
    }

    function authority() external view returns (address) {
        return address(this);
    }
}


Lines covered:	2 / 15 (13.3%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "../EBTCToken.sol";

contract EBTCTokenTester is EBTCToken {
    bytes32 private immutable _PERMIT_TYPEHASH =
        0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;

    constructor(
        address _cdpManagerAddress,
        address _borrowerOperationsAddress,
        address _authorityAddress
    ) EBTCToken(_cdpManagerAddress, _borrowerOperationsAddress, _authorityAddress) {}

    function unprotectedMint(address _account, uint256 _amount) external {
        // No check on caller here

        _mint(_account, _amount);
    }

    function unprotectedBurn(address _account, uint256 _amount) external {
        // No check on caller here

        _burn(_account, _amount);
    }

    function unprotectedSendToPool(address _sender, address _poolAddress, uint256 _amount) external {
        // No check on caller here

        _transfer(_sender, _poolAddress, _amount);
    }

    function unprotectedReturnFromPool(
        address _poolAddress,
        address _receiver,
        uint256 _amount
    ) external {
        // No check on caller here

        _transfer(_poolAddress, _receiver, _amount);
    }

    function callInternalApprove(address owner, address spender, uint256 amount) external {
        _approve(owner, spender, amount);
    }

    function getChainId() external view returns (uint256 chainID) {
        //return _chainID(); // it’s private
        assembly {
            chainID := chainid()
        }
    }

    function getDigest(
        address owner,
        address spender,
        uint256 amount,
        uint256 nonce,
        uint256 deadline
    ) external view returns (bytes32) {
        return
            keccak256(
                abi.encodePacked(
                    uint16(0x1901),
                    domainSeparator(),
                    keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, amount, nonce, deadline))
                )
            );
    }

    function recoverAddress(
        bytes32 digest,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external pure returns (address) {
        return ecrecover(digest, v, r, s);
    }
}


Lines covered:	0 / 14 (0.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "../Interfaces/ICdpManager.sol";
import "../Interfaces/ISortedCdps.sol";
import "../Interfaces/IPriceFeed.sol";
import "../Dependencies/LiquityMath.sol";

/* Wrapper contract - used for calculating gas of read-only and internal functions. 
Not part of the Liquity application. */
contract FunctionCaller {
    ICdpManager cdpManager;
    address public cdpManagerAddress;

    ISortedCdps sortedCdps;
    address public sortedCdpsAddress;

    IPriceFeed priceFeed;
    address public priceFeedAddress;

    // --- Dependency setters ---

    function setCdpManagerAddress(address _cdpManagerAddress) external {
        cdpManagerAddress = _cdpManagerAddress;
        cdpManager = ICdpManager(_cdpManagerAddress);
    }

    function setSortedCdpsAddress(address _sortedCdpsAddress) external {
        cdpManagerAddress = _sortedCdpsAddress;
        sortedCdps = ISortedCdps(_sortedCdpsAddress);
    }

    function setPriceFeedAddress(address _priceFeedAddress) external {
        priceFeedAddress = _priceFeedAddress;
        priceFeed = IPriceFeed(_priceFeedAddress);
    }

    // --- Non-view wrapper functions used for calculating gas ---

    function cdpManager_getICR(bytes32 _cdpId, uint256 _price) external view returns (uint256) {
        return cdpManager.getICR(_cdpId, _price);
    }

    function sortedCdps_findInsertPosition(
        uint256 _NICR,
        bytes32 _prevId,
        bytes32 _nextId
    ) external view returns (bytes32, bytes32) {
        return sortedCdps.findInsertPosition(_NICR, _prevId, _nextId);
    }
}


Lines covered:	0 / 91 (0.0%)

// https://github.com/one-hundred-proof/kyberswap-exploit/blob/main/lib/helpers/Pretty.sol

pragma solidity 0.8.17;

library Strings {
    function concat(
        string memory _base,
        string memory _value
    ) internal pure returns (string memory) {
        bytes memory _baseBytes = bytes(_base);
        bytes memory _valueBytes = bytes(_value);

        string memory _tmpValue = new string(_baseBytes.length + _valueBytes.length);
        bytes memory _newValue = bytes(_tmpValue);

        uint i;
        uint j;

        for (i = 0; i < _baseBytes.length; i++) {
            _newValue[j++] = _baseBytes[i];
        }

        for (i = 0; i < _valueBytes.length; i++) {
            _newValue[j++] = _valueBytes[i];
        }

        return string(_newValue);
    }
}

library Pretty {
    uint8 constant DEFAULT_DECIMALS = 18;

    function toBitString(uint256 n) external pure returns (string memory) {
        return uintToBitString(n, 256);
    }

    function toBitString(uint256 n, uint8 decimals) external pure returns (string memory) {
        return uintToBitString(n, decimals);
    }

    function pretty(uint256 n) external pure returns (string memory) {
        return
            n == type(uint256).max ? "type(uint256).max" : n == type(uint128).max
                ? "type(uint128).max"
                : _pretty(n, DEFAULT_DECIMALS);
    }

    function pretty(bool value) external pure returns (string memory) {
        return value ? "true" : "false";
    }

    function pretty(uint256 n, uint8 decimals) external pure returns (string memory) {
        return _pretty(n, decimals);
    }

    function pretty(int256 n) external pure returns (string memory) {
        return _prettyInt(n, DEFAULT_DECIMALS);
    }

    function pretty(int256 n, uint8 decimals) external pure returns (string memory) {
        return _prettyInt(n, decimals);
    }

    function _pretty(uint256 n, uint8 decimals) internal pure returns (string memory) {
        bool pastDecimals = decimals == 0;
        uint256 place = 0;
        uint256 r; // remainder
        string memory s = "";

        while (n != 0) {
            r = n % 10;
            n /= 10;
            place++;
            s = Strings.concat(toDigit(r), s);
            if (pastDecimals && place % 3 == 0 && n != 0) {
                s = Strings.concat("_", s);
            }
            if (!pastDecimals && place == decimals) {
                pastDecimals = true;
                place = 0;
                s = Strings.concat("_", s);
            }
        }
        if (pastDecimals && place == 0) {
            s = Strings.concat("0", s);
        }
        if (!pastDecimals) {
            uint256 i;
            uint256 upper = (decimals >= place ? decimals - place : 0);
            for (i = 0; i < upper; ++i) {
                s = Strings.concat("0", s);
            }
            s = Strings.concat("0_", s);
        }
        return s;
    }

    function _prettyInt(int256 n, uint8 decimals) internal pure returns (string memory) {
        bool isNegative = n < 0;
        string memory s = "";
        if (isNegative) {
            s = "-";
        }
        return Strings.concat(s, _pretty(uint256(isNegative ? -n : n), decimals));
    }

    function toDigit(uint256 n) internal pure returns (string memory) {
        if (n == 0) {
            return "0";
        } else if (n == 1) {
            return "1";
        } else if (n == 2) {
            return "2";
        } else if (n == 3) {
            return "3";
        } else if (n == 4) {
            return "4";
        } else if (n == 5) {
            return "5";
        } else if (n == 6) {
            return "6";
        } else if (n == 7) {
            return "7";
        } else if (n == 8) {
            return "8";
        } else if (n == 9) {
            return "9";
        } else {
            revert("Not in range 0 to 10");
        }
    }

    function uintToBitString(uint256 n, uint16 bits) internal pure returns (string memory) {
        string memory s = "";
        for (uint256 i; i < bits; i++) {
            if (n % 2 == 0) {
                s = Strings.concat("0", s);
            } else {
                s = Strings.concat("1", s);
            }
            n = n / 2;
        }
        return s;
    }
}


Lines covered:	0 / 29 (0.0%)

/**
 *Submitted for verification at Etherscan.io on 2017-12-12
 */

// Copyright (C) 2015, 2016, 2017 Dapphub

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity 0.8.17;

contract WETH9 {
    string public name = "Wrapped Ether";
    string public symbol = "WETH";
    uint8 public decimals = 18;

    event Approval(address indexed src, address indexed guy, uint256 wad);
    event Transfer(address indexed src, address indexed dst, uint256 wad);
    event Deposit(address indexed dst, uint256 wad);
    event Withdrawal(address indexed src, uint256 wad);

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function receive() public payable {
        deposit();
    }

    function deposit() public payable {
        balanceOf[msg.sender] += msg.value;
        emit Deposit(msg.sender, msg.value);
    }

    function withdraw(uint256 wad) public {
        require(balanceOf[msg.sender] >= wad);
        balanceOf[msg.sender] -= wad;
        payable(msg.sender).transfer(wad);
        emit Withdrawal(msg.sender, wad);
    }

    function totalSupply() public view returns (uint256) {
        return address(this).balance;
    }

    function approve(address guy, uint256 wad) public returns (bool) {
        allowance[msg.sender][guy] = wad;
        emit Approval(msg.sender, guy, wad);
        return true;
    }

    function transfer(address dst, uint256 wad) public virtual returns (bool) {
        return transferFrom(msg.sender, dst, wad);
    }

    function transferFrom(address src, address dst, uint256 wad) public returns (bool) {
        require(balanceOf[src] >= wad);

        if (src != msg.sender && allowance[src][msg.sender] != type(uint256).max) {
            require(allowance[src][msg.sender] >= wad);
            allowance[src][msg.sender] -= wad;
        }

        balanceOf[src] -= wad;
        balanceOf[dst] += wad;

        emit Transfer(src, dst, wad);

        return true;
    }
}

/*
                    GNU GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007

 Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

                            Preamble

  The GNU General Public License is a free, copyleft license for
software and other kinds of works.

  The licenses for most software and other practical works are designed
to take away your freedom to share and change the works.  By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.  We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors.  You can apply it to
your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.

  To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights.  Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received.  You must make sure that they, too, receive
or can get the source code.  And you must show them these terms so they
know their rights.

  Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.

  For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software.  For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.

  Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so.  This is fundamentally incompatible with the aim of
protecting users' freedom to change the software.  The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable.  Therefore, we
have designed this version of the GPL to prohibit the practice for those
products.  If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.

  Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary.  To prevent this, the GPL assures that
patents cannot be used to render the program non-free.

  The precise terms and conditions for copying, distribution and
modification follow.

                       TERMS AND CONDITIONS

  0. Definitions.

  "This License" refers to version 3 of the GNU General Public License.

  "Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.

  "The Program" refers to any copyrightable work licensed under this
License.  Each licensee is addressed as "you".  "Licensees" and
"recipients" may be individuals or organizations.

  To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy.  The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.

  A "covered work" means either the unmodified Program or a work based
on the Program.

  To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy.  Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.

  To "convey" a work means any kind of propagation that enables other
parties to make or receive copies.  Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.

  An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License.  If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.

  1. Source Code.

  The "source code" for a work means the preferred form of the work
for making modifications to it.  "Object code" means any non-source
form of a work.

  A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.

  The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form.  A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.

  The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities.  However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work.  For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.

  The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.

  The Corresponding Source for a work in source code form is that
same work.

  2. Basic Permissions.

  All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met.  This License explicitly affirms your unlimited
permission to run the unmodified Program.  The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work.  This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.

  You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force.  You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright.  Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.

  Conveying under any other circumstances is permitted solely under
the conditions stated below.  Sublicensing is not allowed; section 10
makes it unnecessary.

  3. Protecting Users' Legal Rights From Anti-Circumvention Law.

  No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.

  When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.

  4. Conveying Verbatim Copies.

  You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.

  You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.

  5. Conveying Modified Source Versions.

  You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:

    a) The work must carry prominent notices stating that you modified
    it, and giving a relevant date.

    b) The work must carry prominent notices stating that it is
    released under this License and any conditions added under section
    7.  This requirement modifies the requirement in section 4 to
    "keep intact all notices".

    c) You must license the entire work, as a whole, under this
    License to anyone who comes into possession of a copy.  This
    License will therefore apply, along with any applicable section 7
    additional terms, to the whole of the work, and all its parts,
    regardless of how they are packaged.  This License gives no
    permission to license the work in any other way, but it does not
    invalidate such permission if you have separately received it.

    d) If the work has interactive user interfaces, each must display
    Appropriate Legal Notices; however, if the Program has interactive
    interfaces that do not display Appropriate Legal Notices, your
    work need not make them do so.

  A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit.  Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.

  6. Conveying Non-Source Forms.

  You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:

    a) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by the
    Corresponding Source fixed on a durable physical medium
    customarily used for software interchange.

    b) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by a
    written offer, valid for at least three years and valid for as
    long as you offer spare parts or customer support for that product
    model, to give anyone who possesses the object code either (1) a
    copy of the Corresponding Source for all the software in the
    product that is covered by this License, on a durable physical
    medium customarily used for software interchange, for a price no
    more than your reasonable cost of physically performing this
    conveying of source, or (2) access to copy the
    Corresponding Source from a network server at no charge.

    c) Convey individual copies of the object code with a copy of the
    written offer to provide the Corresponding Source.  This
    alternative is allowed only occasionally and noncommercially, and
    only if you received the object code with such an offer, in accord
    with subsection 6b.

    d) Convey the object code by offering access from a designated
    place (gratis or for a charge), and offer equivalent access to the
    Corresponding Source in the same way through the same place at no
    further charge.  You need not require recipients to copy the
    Corresponding Source along with the object code.  If the place to
    copy the object code is a network server, the Corresponding Source
    may be on a different server (operated by you or a third party)
    that supports equivalent copying facilities, provided you maintain
    clear directions next to the object code saying where to find the
    Corresponding Source.  Regardless of what server hosts the
    Corresponding Source, you remain obligated to ensure that it is
    available for as long as needed to satisfy these requirements.

    e) Convey the object code using peer-to-peer transmission, provided
    you inform other peers where the object code and Corresponding
    Source of the work are being offered to the general public at no
    charge under subsection 6d.

  A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.

  A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling.  In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage.  For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product.  A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.

  "Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source.  The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.

  If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information.  But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).

  The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed.  Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law.  If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.

  When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it.  (Additional permissions may be written to require their own
removal in certain cases when you modify the work.)  You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.

  Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:

    a) Disclaiming warranty or limiting liability differently from the
    terms of sections 15 and 16 of this License; or

    b) Requiring preservation of specified reasonable legal notices or
    author attributions in that material or in the Appropriate Legal
    Notices displayed by works containing it; or

    c) Prohibiting misrepresentation of the origin of that material, or
    requiring that modified versions of such material be marked in
    reasonable ways as different from the original version; or

    d) Limiting the use for publicity purposes of names of licensors or
    authors of the material; or

    e) Declining to grant rights under trademark law for use of some
    trade names, trademarks, or service marks; or

    f) Requiring indemnification of licensors and authors of that
    material by anyone who conveys the material (or modified versions of
    it) with contractual assumptions of liability to the recipient, for
    any liability that these contractual assumptions directly impose on
    those licensors and authors.

  All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10.  If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term.  If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.

  If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.

  Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.

  8. Termination.

  You may not propagate or modify a covered work except as expressly
provided under this License.  Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).

  However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.

  Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.

  Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License.  If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.

  9. Acceptance Not Required for Having Copies.

  You are not required to accept this License in order to receive or
run a copy of the Program.  Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance.  However,
nothing other than this License grants you permission to propagate or
modify any covered work.  These actions infringe copyright if you do
not accept this License.  Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.

  10. Automatic Licensing of Downstream Recipients.

  Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License.  You are not responsible
for enforcing compliance by third parties with this License.

  An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations.  If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.

  You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License.  For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.

  11. Patents.

  A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based.  The
work thus licensed is called the contributor's "contributor version".

  A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version.  For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.

  Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.

  In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement).  To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.

  If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients.  "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.

  If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.

  A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License.  You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.

  Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.

  12. No Surrender of Others' Freedom.

  If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all.  For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.

  13. Use with the GNU Affero General Public License.

  Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work.  The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.

  14. Revised Versions of this License.

  The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

  Each version is given a distinguishing version number.  If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation.  If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.

  If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.

  Later license versions may give you additional or different
permissions.  However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.

  15. Disclaimer of Warranty.

  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

  16. Limitation of Liability.

  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.

  17. Interpretation of Sections 15 and 16.

  If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.

                     END OF TERMS AND CONDITIONS

            How to Apply These Terms to Your New Programs

  If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

  To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

Also add information on how to contact you by electronic and paper mail.

  If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:

    <program>  Copyright (C) <year>  <name of author>
    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".

  You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.

  The GNU General Public License does not permit incorporating your program
into proprietary programs.  If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library.  If this is what you want to do, use the GNU Lesser General
Public License instead of this License.  But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.

*/


Lines covered:	8 / 23 (34.8%)

pragma solidity 0.8.17;

import {IERC3156FlashBorrower} from "../../Interfaces/IERC3156FlashBorrower.sol";
import {IERC20} from "../../Dependencies/IERC20.sol";

contract Actor is IERC3156FlashBorrower {
    address[] internal tokens;
    address[] internal callers;

    constructor(address[] memory _tokens, address[] memory _callers) payable {
        tokens = _tokens;
        callers = _callers;
        for (uint256 i = 0; i < tokens.length; i++) {
            IERC20(tokens[i]).approve(callers[i], type(uint256).max);
        }
    }

    function proxy(
        address _target,
        bytes memory _calldata
    ) public returns (bool success, bytes memory returnData) {
        (success, returnData) = address(_target).call(_calldata);
    }

    function proxy(
        address _target,
        bytes memory _calldata,
        uint256 value
    ) public returns (bool success, bytes memory returnData) {
        (success, returnData) = address(_target).call{value: value}(_calldata);
    }

    receive() external payable {}

    // callback for flashloan
    function onFlashLoan(
        address,
        address token,
        uint256 amount,
        uint256 fee,
        bytes calldata data
    ) external override returns (bytes32) {
        bool isValidCaller = false;
        for (uint256 i = 0; i < tokens.length; i++) {
            if (token == tokens[i]) {
                isValidCaller = msg.sender == callers[i];
                break;
            }
        }
        require(isValidCaller, "Invalid caller");

        if (data.length != 0) {
            (address[] memory _targets, bytes[] memory _calldatas) = abi.decode(
                data,
                (address[], bytes[])
            );
            for (uint256 i = 0; i < _targets.length; ++i) {
                (bool success, ) = address(_targets[i]).call(_calldatas[i]);
                require(success);
            }
        }

        IERC20(token).approve(msg.sender, amount + fee);

        return keccak256("ERC3156FlashBorrower.onFlashLoan");
    }
}


Lines covered:	21 / 31 (67.7%)

pragma solidity 0.8.17;

abstract contract Asserts {
    event L1(uint256);
    event L2(uint256, uint256);
    event L3(uint256, uint256, uint256);
    event L4(uint256, uint256, uint256, uint256);

    function gt(uint256 a, uint256 b, string memory reason) internal virtual;

    function gte(uint256 a, uint256 b, string memory reason) internal virtual;

    function lt(uint256 a, uint256 b, string memory reason) internal virtual;

    function lte(uint256 a, uint256 b, string memory reason) internal virtual;

    function eq(uint256 a, uint256 b, string memory reason) internal virtual;

    function t(bool b, string memory reason) internal virtual;

    function between(uint256 value, uint256 low, uint256 high) internal virtual returns (uint256);

    function isApproximateEq(
        uint256 _num1,
        uint256 _num2,
        uint256 _tolerance
    ) internal pure returns (bool) {
        return diffPercent(_num1, _num2) <= _tolerance;
    }

    function diffPercent(uint256 _num1, uint256 _num2) internal pure returns (uint256) {
        if (_num1 == _num2) return 0;
        else if (_num1 > _num2) {
            return ((_num1 - _num2) * 1e18) / ((_num1 + _num2) / 2);
        } else {
            return ((_num2 - _num1) * 1e18) / ((_num1 + _num2) / 2);
        }
    }

    // https://ethereum.stackexchange.com/a/83577
    function _getRevertMsg(bytes memory returnData) internal pure returns (string memory) {
        // Check that the data has the right size: 4 bytes for signature + 32 bytes for panic code
        if (returnData.length == 4 + 32) {
            // Check that the data starts with the Panic signature
            bytes4 panicSignature = bytes4(keccak256(bytes("Panic(uint256)")));
            for (uint i = 0; i < 4; i++) {
                if (returnData[i] != panicSignature[i]) return "Undefined signature";
            }

            uint256 panicCode;
            for (uint i = 4; i < 36; i++) {
                panicCode = panicCode << 8;
                panicCode |= uint8(returnData[i]);
            }

            // Now convert the panic code into its string representation
            if (panicCode == 17) {
                return "Panic(17)";
            }

            // Add other panic codes as needed or return a generic "Unknown panic"
            return "Undefined panic code";
        }

        // If the returnData length is less than 68, then the transaction failed silently (without a revert message)
        if (returnData.length < 68) return "Transaction reverted silently";

        assembly {
            // Slice the sighash.
            returnData := add(returnData, 0x04)
        }
        return abi.decode(returnData, (string)); // All that remains is the revert string
    }

    function _isRevertReasonEqual(
        bytes memory returnData,
        string memory reason
    ) internal pure returns (bool) {
        return (keccak256(abi.encodePacked(_getRevertMsg(returnData))) ==
            keccak256(abi.encodePacked(reason)));
    }

    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    function assertRevertReasonNotEqual(bytes memory returnData, string memory reason) internal {
        bool isEqual = _isRevertReasonEqual(returnData, reason);
        t(!isEqual, reason);
    }

    function assertRevertReasonEqual(bytes memory returnData, string memory reason) internal {
        bool isEqual = _isRevertReasonEqual(returnData, reason);
        t(isEqual, reason);
    }

    function assertRevertReasonEqual(
        bytes memory returnData,
        string memory reason1,
        string memory reason2
    ) internal {
        bool isEqual = _isRevertReasonEqual(returnData, reason1) ||
            _isRevertReasonEqual(returnData, reason2);
        t(isEqual, string.concat(reason1, " OR ", reason2));
    }

    function assertRevertReasonEqual(
        bytes memory returnData,
        string memory reason1,
        string memory reason2,
        string memory reason3
    ) internal {
        bool isEqual = _isRevertReasonEqual(returnData, reason1) ||
            _isRevertReasonEqual(returnData, reason2) ||
            _isRevertReasonEqual(returnData, reason3);
        t(isEqual, string.concat(reason1, " OR ", reason2, " OR ", reason3));
    }

    function assertRevertReasonEqual(
        bytes memory returnData,
        string memory reason1,
        string memory reason2,
        string memory reason3,
        string memory reason4
    ) internal {
        bool isEqual = _isRevertReasonEqual(returnData, reason1) ||
            _isRevertReasonEqual(returnData, reason2) ||
            _isRevertReasonEqual(returnData, reason3) ||
            _isRevertReasonEqual(returnData, reason4);
        t(isEqual, string.concat(reason1, " OR ", reason2, " OR ", reason3, " OR ", reason4));
    }
}


Lines covered:	81 / 81 (100.0%)

pragma solidity 0.8.17;

import {Pretty, Strings} from "../Pretty.sol";
import {BaseStorageVariables} from "../BaseStorageVariables.sol";

abstract contract BeforeAfter is BaseStorageVariables {
    using Strings for string;
    using Pretty for uint256;
    using Pretty for int256;
    using Pretty for bool;

    struct Vars {
        uint256 nicrBefore;
        uint256 nicrAfter;
        uint256 icrBefore;
        uint256 icrAfter;
        uint256 newIcrBefore;
        uint256 newIcrAfter;
        uint256 feeSplitBefore;
        uint256 feeSplitAfter;
        uint256 feeRecipientTotalCollBefore;
        uint256 feeRecipientTotalCollAfter;
        uint256 feeRecipientCollSharesBefore;
        uint256 feeRecipientCollSharesAfter;
        uint256 actorCollBefore;
        uint256 actorCollAfter;
        uint256 actorEbtcBefore;
        uint256 actorEbtcAfter;
        uint256 actorCdpCountBefore;
        uint256 actorCdpCountAfter;
        uint256 cdpCollBefore;
        uint256 cdpCollAfter;
        uint256 cdpDebtBefore;
        uint256 cdpDebtAfter;
        uint256 liquidatorRewardSharesBefore;
        uint256 liquidatorRewardSharesAfter;
        uint256 sortedCdpsSizeBefore;
        uint256 sortedCdpsSizeAfter;
        uint256 cdpStatusBefore;
        uint256 cdpStatusAfter;
        uint256 tcrBefore;
        uint256 tcrAfter;
        uint256 newTcrBefore;
        uint256 newTcrAfter;
        uint256 ebtcTotalSupplyBefore;
        uint256 ebtcTotalSupplyAfter;
        uint256 ethPerShareBefore;
        uint256 ethPerShareAfter;
        uint256 activePoolCollBefore;
        uint256 activePoolCollAfter;
        uint256 activePoolDebtBefore;
        uint256 activePoolDebtAfter;
        uint256 collSurplusPoolBefore;
        uint256 collSurplusPoolAfter;
        uint256 priceBefore;
        uint256 priceAfter;
        bool isRecoveryModeBefore;
        bool isRecoveryModeAfter;
        uint256 lastGracePeriodStartTimestampBefore;
        uint256 lastGracePeriodStartTimestampAfter;
        bool lastGracePeriodStartTimestampIsSetBefore;
        bool lastGracePeriodStartTimestampIsSetAfter;
        bool hasGracePeriodPassedBefore;
        bool hasGracePeriodPassedAfter;
        uint256 systemDebtRedistributionIndexBefore;
        uint256 systemDebtRedistributionIndexAfter;
    }

    Vars vars;
    struct Cdp {
        bytes32 id;
        uint256 icr;
    }

    function _before(bytes32 _cdpId) internal {
        vars.priceBefore = priceFeedMock.fetchPrice();

        (uint256 debtBefore, , ) = cdpManager.getDebtAndCollShares(_cdpId);

        vars.nicrBefore = _cdpId != bytes32(0) ? crLens.quoteRealNICR(_cdpId) : 0;
        vars.icrBefore = _cdpId != bytes32(0) ? cdpManager.getICR(_cdpId, vars.priceBefore) : 0;
        vars.cdpCollBefore = _cdpId != bytes32(0) ? cdpManager.getCdpCollShares(_cdpId) : 0;
        vars.cdpDebtBefore = _cdpId != bytes32(0) ? debtBefore : 0;
        vars.liquidatorRewardSharesBefore = _cdpId != bytes32(0)
            ? cdpManager.getCdpLiquidatorRewardShares(_cdpId)
            : 0;
        vars.cdpStatusBefore = _cdpId != bytes32(0) ? cdpManager.getCdpStatus(_cdpId) : 0;

        vars.isRecoveryModeBefore = crLens.quoteCheckRecoveryMode() == 1; /// @audit crLens
        (vars.feeSplitBefore, , ) = collateral.getPooledEthByShares(cdpManager.DECIMAL_PRECISION()) >
            cdpManager.stEthIndex()
            ? cdpManager.calcFeeUponStakingReward(
                collateral.getPooledEthByShares(cdpManager.DECIMAL_PRECISION()),
                cdpManager.stEthIndex()
            )
            : (0, 0, 0);
        vars.feeRecipientTotalCollBefore =
            activePool.getFeeRecipientClaimableCollShares() +
            collateral.balanceOf(activePool.feeRecipientAddress());
        vars.feeRecipientCollSharesBefore = activePool.getFeeRecipientClaimableCollShares();
        vars.actorCollBefore = collateral.balanceOf(address(actor));
        vars.actorEbtcBefore = eBTCToken.balanceOf(address(actor));
        vars.actorCdpCountBefore = sortedCdps.cdpCountOf(address(actor));
        vars.sortedCdpsSizeBefore = sortedCdps.getSize();
        vars.tcrBefore = cdpManager.getTCR(vars.priceBefore);
        vars.ebtcTotalSupplyBefore = eBTCToken.totalSupply();
        vars.ethPerShareBefore = collateral.getEthPerShare();
        vars.activePoolDebtBefore = activePool.getSystemDebt();
        vars.activePoolCollBefore = activePool.getSystemCollShares();
        vars.collSurplusPoolBefore = collSurplusPool.getTotalSurplusCollShares();
        vars.lastGracePeriodStartTimestampBefore = cdpManager.lastGracePeriodStartTimestamp();
        vars.lastGracePeriodStartTimestampIsSetBefore =
            cdpManager.lastGracePeriodStartTimestamp() != cdpManager.UNSET_TIMESTAMP();
        vars.hasGracePeriodPassedBefore =
            cdpManager.lastGracePeriodStartTimestamp() != cdpManager.UNSET_TIMESTAMP() &&
            block.timestamp >
            cdpManager.lastGracePeriodStartTimestamp() + cdpManager.recoveryModeGracePeriod();
        vars.systemDebtRedistributionIndexBefore = cdpManager.systemDebtRedistributionIndex();

        vars.newTcrBefore = crLens.quoteRealTCR();
        vars.newIcrBefore = crLens.quoteRealICR(_cdpId);
    }

    function _after(bytes32 _cdpId) internal {
        vars.priceAfter = priceFeedMock.fetchPrice();

        vars.nicrAfter = _cdpId != bytes32(0) ? crLens.quoteRealNICR(_cdpId) : 0;
        vars.icrAfter = _cdpId != bytes32(0) ? cdpManager.getICR(_cdpId, vars.priceAfter) : 0;
        vars.cdpCollAfter = _cdpId != bytes32(0) ? cdpManager.getCdpCollShares(_cdpId) : 0;
        vars.cdpDebtAfter = _cdpId != bytes32(0) ? cdpManager.getCdpDebt(_cdpId) : 0;
        vars.liquidatorRewardSharesAfter = _cdpId != bytes32(0)
            ? cdpManager.getCdpLiquidatorRewardShares(_cdpId)
            : 0;
        vars.cdpStatusAfter = _cdpId != bytes32(0) ? cdpManager.getCdpStatus(_cdpId) : 0;

        vars.isRecoveryModeAfter = cdpManager.checkRecoveryMode(vars.priceAfter); /// @audit This is fine as is because after the system is synched
        (vars.feeSplitAfter, , ) = collateral.getPooledEthByShares(cdpManager.DECIMAL_PRECISION()) >
            cdpManager.stEthIndex()
            ? cdpManager.calcFeeUponStakingReward(
                collateral.getPooledEthByShares(cdpManager.DECIMAL_PRECISION()),
                cdpManager.stEthIndex()
            )
            : (0, 0, 0);
        vars.feeRecipientTotalCollAfter =
            activePool.getFeeRecipientClaimableCollShares() +
            collateral.balanceOf(activePool.feeRecipientAddress());
        vars.feeRecipientCollSharesAfter = activePool.getFeeRecipientClaimableCollShares();
        vars.actorCollAfter = collateral.balanceOf(address(actor));
        vars.actorEbtcAfter = eBTCToken.balanceOf(address(actor));
        vars.actorCdpCountAfter = sortedCdps.cdpCountOf(address(actor));
        vars.sortedCdpsSizeAfter = sortedCdps.getSize();
        vars.tcrAfter = cdpManager.getTCR(vars.priceAfter);
        vars.ebtcTotalSupplyAfter = eBTCToken.totalSupply();
        vars.ethPerShareAfter = collateral.getEthPerShare();
        vars.activePoolDebtAfter = activePool.getSystemDebt();
        vars.activePoolCollAfter = activePool.getSystemCollShares();
        vars.collSurplusPoolAfter = collSurplusPool.getTotalSurplusCollShares();
        vars.lastGracePeriodStartTimestampAfter = cdpManager.lastGracePeriodStartTimestamp();
        vars.lastGracePeriodStartTimestampIsSetAfter =
            cdpManager.lastGracePeriodStartTimestamp() != cdpManager.UNSET_TIMESTAMP();
        vars.hasGracePeriodPassedAfter =
            cdpManager.lastGracePeriodStartTimestamp() != cdpManager.UNSET_TIMESTAMP() &&
            block.timestamp >
            cdpManager.lastGracePeriodStartTimestamp() + cdpManager.recoveryModeGracePeriod();
        vars.systemDebtRedistributionIndexAfter = cdpManager.systemDebtRedistributionIndex();

        vars.newTcrAfter = crLens.quoteRealTCR();
        vars.newIcrAfter = crLens.quoteRealICR(_cdpId);
    }

    function _diff() internal view returns (string memory log) {
        log = string("\n\t\t\t\tBefore\t\t\tAfter\n");
        if (vars.activePoolCollBefore != vars.activePoolCollAfter) {
            log = log
                .concat("activePoolColl\t\t\t")
                .concat(vars.activePoolCollBefore.pretty())
                .concat("\t")
                .concat(vars.activePoolCollAfter.pretty())
                .concat("\n");
        }
        if (vars.collSurplusPoolBefore != vars.collSurplusPoolAfter) {
            log = log
                .concat("collSurplusPool\t\t\t")
                .concat(vars.collSurplusPoolBefore.pretty())
                .concat("\t")
                .concat(vars.collSurplusPoolAfter.pretty())
                .concat("\n");
        }
        if (vars.nicrBefore != vars.nicrAfter) {
            log = log
                .concat("nicr\t\t\t\t")
                .concat(vars.nicrBefore.pretty())
                .concat("\t")
                .concat(vars.nicrAfter.pretty())
                .concat("\n");
        }
        if (vars.icrBefore != vars.icrAfter) {
            log = log
                .concat("icr\t\t\t\t")
                .concat(vars.icrBefore.pretty())
                .concat("\t")
                .concat(vars.icrAfter.pretty())
                .concat("\n");
        }
        if (vars.newIcrBefore != vars.newIcrAfter) {
            log = log
                .concat("newIcr\t\t\t\t")
                .concat(vars.newIcrBefore.pretty())
                .concat("\t")
                .concat(vars.newIcrAfter.pretty())
                .concat("\n");
        }
        if (vars.feeSplitBefore != vars.feeSplitAfter) {
            log = log
                .concat("feeSplit\t\t\t\t")
                .concat(vars.feeSplitBefore.pretty())
                .concat("\t")
                .concat(vars.feeSplitAfter.pretty())
                .concat("\n");
        }
        if (vars.feeRecipientTotalCollBefore != vars.feeRecipientTotalCollAfter) {
            log = log
                .concat("feeRecipientTotalColl\t")
                .concat(vars.feeRecipientTotalCollBefore.pretty())
                .concat("\t")
                .concat(vars.feeRecipientTotalCollAfter.pretty())
                .concat("\n");
        }
        if (vars.actorCollBefore != vars.actorCollAfter) {
            log = log
                .concat("actorColl\t\t\t\t")
                .concat(vars.actorCollBefore.pretty())
                .concat("\t")
                .concat(vars.actorCollAfter.pretty())
                .concat("\n");
        }
        if (vars.actorEbtcBefore != vars.actorEbtcAfter) {
            log = log
                .concat("actorEbtc\t\t\t\t")
                .concat(vars.actorEbtcBefore.pretty())
                .concat("\t")
                .concat(vars.actorEbtcAfter.pretty())
                .concat("\n");
        }
        if (vars.actorCdpCountBefore != vars.actorCdpCountAfter) {
            log = log
                .concat("actorCdpCount\t\t\t")
                .concat(vars.actorCdpCountBefore.pretty())
                .concat("\t")
                .concat(vars.actorCdpCountAfter.pretty())
                .concat("\n");
        }
        if (vars.cdpCollBefore != vars.cdpCollAfter) {
            log = log
                .concat("cdpColl\t\t\t\t")
                .concat(vars.cdpCollBefore.pretty())
                .concat("\t")
                .concat(vars.cdpCollAfter.pretty())
                .concat("\n");
        }
        if (vars.cdpDebtBefore != vars.cdpDebtAfter) {
            log = log
                .concat("cdpDebt\t\t\t\t")
                .concat(vars.cdpDebtBefore.pretty())
                .concat("\t")
                .concat(vars.cdpDebtAfter.pretty())
                .concat("\n");
        }
        if (vars.liquidatorRewardSharesBefore != vars.liquidatorRewardSharesAfter) {
            log = log
                .concat("liquidatorRewardShares\t\t")
                .concat(vars.liquidatorRewardSharesBefore.pretty())
                .concat("\t")
                .concat(vars.liquidatorRewardSharesAfter.pretty())
                .concat("\n");
        }
        if (vars.sortedCdpsSizeBefore != vars.sortedCdpsSizeAfter) {
            log = log
                .concat("sortedCdpsSize\t\t\t")
                .concat(vars.sortedCdpsSizeBefore.pretty(0))
                .concat("\t\t\t")
                .concat(vars.sortedCdpsSizeAfter.pretty(0))
                .concat("\n");
        }
        if (vars.cdpStatusBefore != vars.cdpStatusAfter) {
            log = log
                .concat("cdpStatus\t\t\t")
                .concat(vars.cdpStatusBefore.pretty(0))
                .concat("\t\t\t")
                .concat(vars.cdpStatusAfter.pretty(0))
                .concat("\n");
        }
        if (vars.tcrBefore != vars.tcrAfter) {
            log = log
                .concat("tcr\t\t\t\t")
                .concat(vars.tcrBefore.pretty())
                .concat("\t")
                .concat(vars.tcrAfter.pretty())
                .concat("\n");
        }
        if (vars.newTcrBefore != vars.newTcrAfter) {
            log = log
                .concat("newTcr\t\t\t\t")
                .concat(vars.newTcrBefore.pretty())
                .concat("\t")
                .concat(vars.newTcrAfter.pretty())
                .concat("\n");
        }
        if (vars.ebtcTotalSupplyBefore != vars.ebtcTotalSupplyAfter) {
            log = log
                .concat("ebtcTotalSupply\t\t\t")
                .concat(vars.ebtcTotalSupplyBefore.pretty())
                .concat("\t")
                .concat(vars.ebtcTotalSupplyAfter.pretty())
                .concat("\n");
        }
        if (vars.ethPerShareBefore != vars.ethPerShareAfter) {
            log = log
                .concat("ethPerShare\t\t\t")
                .concat(vars.ethPerShareBefore.pretty())
                .concat("\t")
                .concat(vars.ethPerShareAfter.pretty())
                .concat("\n");
        }
        if (vars.isRecoveryModeBefore != vars.isRecoveryModeAfter) {
            log = log
                .concat("isRecoveryMode\t\t\t")
                .concat(vars.isRecoveryModeBefore.pretty())
                .concat("\t")
                .concat(vars.isRecoveryModeAfter.pretty())
                .concat("\n");
        }
        if (vars.lastGracePeriodStartTimestampBefore != vars.lastGracePeriodStartTimestampAfter) {
            log = log
                .concat("lastGracePeriodStartTimestamp\t")
                .concat(vars.lastGracePeriodStartTimestampBefore.pretty())
                .concat("\t")
                .concat(vars.lastGracePeriodStartTimestampAfter.pretty())
                .concat("\n");
        }
        if (
            vars.lastGracePeriodStartTimestampIsSetBefore !=
            vars.lastGracePeriodStartTimestampIsSetAfter
        ) {
            log = log
                .concat("lastGracePeriodStartTimestampIsSet\t")
                .concat(vars.lastGracePeriodStartTimestampIsSetBefore.pretty())
                .concat("\t")
                .concat(vars.lastGracePeriodStartTimestampIsSetAfter.pretty())
                .concat("\n");
        }
        if (vars.hasGracePeriodPassedBefore != vars.hasGracePeriodPassedAfter) {
            log = log
                .concat("hasGracePeriodPassed\t\t")
                .concat(vars.hasGracePeriodPassedBefore.pretty())
                .concat("\t\t\t")
                .concat(vars.hasGracePeriodPassedAfter.pretty())
                .concat("\n");
        }
        if (vars.systemDebtRedistributionIndexBefore != vars.systemDebtRedistributionIndexAfter) {
            log = log
                .concat("systemDebtRedistributionIndex\t\t")
                .concat(vars.systemDebtRedistributionIndexBefore.pretty())
                .concat("\t")
                .concat(vars.systemDebtRedistributionIndexAfter.pretty())
                .concat("\n");
        }
    }
}


Lines covered:	189 / 200 (94.5%)

pragma solidity 0.8.17;

import "@crytic/properties/contracts/util/PropertiesConstants.sol";

import {ICollateralToken} from "../../Dependencies/ICollateralToken.sol";
import {LiquityMath} from "../../Dependencies/LiquityMath.sol";
import {ActivePool} from "../../ActivePool.sol";
import {EBTCToken} from "../../EBTCToken.sol";
import {BorrowerOperations} from "../../BorrowerOperations.sol";
import {CdpManager} from "../../CdpManager.sol";
import {SortedCdps} from "../../SortedCdps.sol";
import {Asserts} from "./Asserts.sol";
import {CollSurplusPool} from "../../CollSurplusPool.sol";
import {PriceFeedTestnet} from "../testnet/PriceFeedTestnet.sol";
import {ICdpManagerData} from "../../Interfaces/ICdpManagerData.sol";
import {BeforeAfter} from "./BeforeAfter.sol";
import {PropertiesDescriptions} from "./PropertiesDescriptions.sol";
import {CRLens} from "../../CRLens.sol";
import {LiquidationSequencer} from "../../LiquidationSequencer.sol";
import {SyncedLiquidationSequencer} from "../../SyncedLiquidationSequencer.sol";

abstract contract Properties is BeforeAfter, PropertiesDescriptions, Asserts, PropertiesConstants {
    function invariant_AP_01(
        ICollateralToken collateral,
        ActivePool activePool
    ) internal view returns (bool) {
        return (collateral.sharesOf(address(activePool)) >= activePool.getSystemCollShares());
    }

    function invariant_AP_02(
        CdpManager cdpManager,
        ActivePool activePool
    ) internal view returns (bool) {
        return cdpManager.getActiveCdpsCount() > 0 ? activePool.getSystemCollShares() > 0 : true;
    }

    function invariant_AP_03(
        EBTCToken eBTCToken,
        ActivePool activePool
    ) internal view returns (bool) {
        return (eBTCToken.totalSupply() == activePool.getSystemDebt());
    }

    function invariant_AP_04(
        CdpManager cdpManager,
        ActivePool activePool,
        uint256 diff_tolerance
    ) internal view returns (bool) {
        uint256 _cdpCount = cdpManager.getActiveCdpsCount();
        uint256 _sum;
        for (uint256 i = 0; i < _cdpCount; ++i) {
            (, uint256 _coll, ) = cdpManager.getDebtAndCollShares(cdpManager.CdpIds(i));
            _sum += _coll;
        }
        uint256 _activeColl = activePool.getSystemCollShares();
        uint256 _diff = _sum > _activeColl ? (_sum - _activeColl) : (_activeColl - _sum);
        return (_diff * 1e18 <= diff_tolerance * _activeColl);
    }

    function invariant_AP_05(
        CdpManager cdpManager,
        uint256 diff_tolerance
    ) internal view returns (bool) {
        uint256 _cdpCount = cdpManager.getActiveCdpsCount();
        uint256 _sum;
        for (uint256 i = 0; i < _cdpCount; ++i) {
            (uint256 _debt, , ) = cdpManager.getDebtAndCollShares(cdpManager.CdpIds(i));
            _sum += _debt;
        }

        bool oldCheck = isApproximateEq(_sum, cdpManager.getSystemDebt(), diff_tolerance);
        // New check ensures this is above 1000 wei
        bool newCheck = cdpManager.getSystemDebt() - _sum > 1_000;
        // @audit We have an instance of getting above 1e18 in rounding error, see `testBrokenInvariantFive`
        return oldCheck || !newCheck;
    }

    function invariant_CDPM_01(
        CdpManager cdpManager,
        SortedCdps sortedCdps
    ) internal view returns (bool) {
        return (cdpManager.getActiveCdpsCount() == sortedCdps.getSize());
    }

    function invariant_CDPM_02(CdpManager cdpManager) internal view returns (bool) {
        uint256 _cdpCount = cdpManager.getActiveCdpsCount();
        uint256 _sum;
        for (uint256 i = 0; i < _cdpCount; ++i) {
            _sum += cdpManager.getCdpStake(cdpManager.CdpIds(i));
        }
        return (_sum == cdpManager.totalStakes());
    }

    function invariant_CDPM_03(CdpManager cdpManager) internal view returns (bool) {
        uint256 _cdpCount = cdpManager.getActiveCdpsCount();
        uint256 systemStEthFeePerUnitIndex = cdpManager.systemStEthFeePerUnitIndex();
        for (uint256 i = 0; i < _cdpCount; ++i) {
            if (systemStEthFeePerUnitIndex < cdpManager.stEthFeePerUnitIndex(cdpManager.CdpIds(i))) {
                return false;
            }
        }
        return true;
    }

    /** TODO: See EchidnaToFoundry._getValue */
    function invariant_CDPM_04(Vars memory vars) internal view returns (bool) {
        uint256 beforeValue = ((vars.activePoolCollBefore +
            vars.collSurplusPoolBefore +
            vars.feeRecipientTotalCollBefore) * vars.priceBefore) /
            1e18 -
            vars.activePoolDebtBefore;

        uint256 afterValue = ((vars.activePoolCollAfter +
            vars.collSurplusPoolAfter +
            vars.feeRecipientTotalCollAfter) * vars.priceAfter) /
            1e18 -
            vars.activePoolDebtAfter;

        return afterValue >= beforeValue || isApproximateEq(afterValue, beforeValue, 0.01e18);
    }

    function invariant_CSP_01(
        ICollateralToken collateral,
        CollSurplusPool collSurplusPool
    ) internal view returns (bool) {
        return
            collateral.sharesOf(address(collSurplusPool)) >=
            collSurplusPool.getTotalSurplusCollShares();
    }

    function invariant_CSP_02(CollSurplusPool collSurplusPool) internal view returns (bool) {
        uint256 sum;

        // NOTE: See PropertiesConstants
        // We only have 3 actors so just set these up
        sum += collSurplusPool.getSurplusCollShares(address(actors[USER1]));
        sum += collSurplusPool.getSurplusCollShares(address(actors[USER2]));
        sum += collSurplusPool.getSurplusCollShares(address(actors[USER3]));

        return sum == collSurplusPool.getTotalSurplusCollShares();
    }

    event L(string, uint);

    function invariant_SL_01(CdpManager cdpManager, SortedCdps sortedCdps) internal returns (bool) {
        bytes32 currentCdp = sortedCdps.getFirst();
        bytes32 nextCdp = sortedCdps.getNext(currentCdp);

        while (currentCdp != bytes32(0) && nextCdp != bytes32(0) && currentCdp != nextCdp) {
            // TODO remove tolerance once proper fix has been applied
            uint256 nicrNext = cdpManager.getNominalICR(nextCdp);
            uint256 nicrCurrent = cdpManager.getNominalICR(currentCdp);
            emit L("NICR next", nicrNext);
            emit L("NICR curr", nicrCurrent);
            if (nicrNext > nicrCurrent && diffPercent(nicrNext, nicrCurrent) > 0.01e18) {
                return false;
            }

            currentCdp = nextCdp;
            nextCdp = sortedCdps.getNext(currentCdp);
        }

        return true;
    }

    function invariant_SL_02(
        CdpManager cdpManager,
        SortedCdps sortedCdps,
        PriceFeedTestnet priceFeedMock
    ) internal view returns (bool) {
        bytes32 _first = sortedCdps.getFirst();
        uint256 _price = priceFeedMock.getPrice();
        uint256 _firstICR = cdpManager.getICR(_first, _price);
        uint256 _TCR = cdpManager.getTCR(_price);

        if (
            _first != sortedCdps.dummyId() &&
            _firstICR < _TCR &&
            diffPercent(_firstICR, _TCR) > 0.01e18
        ) {
            return false;
        }
        return true;
    }

    function invariant_SL_03(
        CdpManager cdpManager,
        PriceFeedTestnet priceFeedMock,
        SortedCdps sortedCdps
    ) internal view returns (bool) {
        bytes32 currentCdp = sortedCdps.getFirst();

        uint256 _price = priceFeedMock.getPrice();
        if (_price == 0) return true;

        while (currentCdp != bytes32(0)) {
            // Status
            if (
                ICdpManagerData.Status(cdpManager.getCdpStatus(currentCdp)) !=
                ICdpManagerData.Status.active
            ) {
                return false;
            }

            // Stake > 0
            if (cdpManager.getCdpStake(currentCdp) == 0) {
                return false;
            }

            currentCdp = sortedCdps.getNext(currentCdp);
        }
        return true;
    }

    uint256 NICR_ERROR_THRESHOLD = 1e8;

    function invariant_SL_05(CRLens crLens, SortedCdps sortedCdps) internal returns (bool) {
        bytes32 currentCdp = sortedCdps.getFirst();

        uint256 newIcrPrevious = type(uint256).max;

        while (currentCdp != bytes32(0)) {
            uint256 newIcr = crLens.quoteRealICR(currentCdp);
            if (newIcr > newIcrPrevious) {
                /// @audit Precision Threshold to flag very scary scenarios
                /// Innoquous scenario illustrated here: https://github.com/Badger-Finance/ebtc-fuzz-review/issues/15
                if (newIcr - newIcrPrevious > NICR_ERROR_THRESHOLD) {
                    return false;
                }
            }
            newIcrPrevious = newIcr;

            currentCdp = sortedCdps.getNext(currentCdp);
        }
        return true;
    }

    function invariant_GENERAL_01(Vars memory vars) internal view returns (bool) {
        return !vars.isRecoveryModeBefore ? !vars.isRecoveryModeAfter : true;
    }

    function invariant_GENERAL_02(
        CdpManager cdpManager,
        PriceFeedTestnet priceFeedMock,
        EBTCToken eBTCToken
    ) internal view returns (bool) {
        // TODO how to calculate "the dollar value of eBTC"?
        // TODO how do we take into account underlying/shares into this calculation?
        return
            cdpManager.getTCR(priceFeedMock.getPrice()) > collateral.getPooledEthByShares(1e18)
                ? (cdpManager.getSystemCollShares() * priceFeedMock.getPrice()) / 1e18 >=
                    eBTCToken.totalSupply()
                : (cdpManager.getSystemCollShares() * priceFeedMock.getPrice()) / 1e18 <
                    eBTCToken.totalSupply();
    }

    function invariant_GENERAL_03(
        CdpManager cdpManager,
        BorrowerOperations borrowerOperations,
        EBTCToken eBTCToken,
        ICollateralToken collateral
    ) internal view returns (bool) {
        return
            collateral.balanceOf(address(cdpManager)) == 0 &&
            eBTCToken.balanceOf(address(cdpManager)) == 0 &&
            collateral.balanceOf(address(borrowerOperations)) == 0 &&
            eBTCToken.balanceOf(address(borrowerOperations)) == 0;
    }

    function invariant_GENERAL_05(
        ActivePool activePool,
        CdpManager cdpManager,
        ICollateralToken collateral
    ) internal view returns (bool) {
        uint256 totalStipendShares;

        // Iterate over CDPs add the stipendShares
        bytes32 currentCdp = sortedCdps.getFirst();
        while (currentCdp != bytes32(0)) {
            totalStipendShares += cdpManager.getCdpLiquidatorRewardShares(currentCdp);

            currentCdp = sortedCdps.getNext(currentCdp);
        }

        return
            collateral.sharesOf(address(activePool)) >=
            (activePool.getSystemCollShares() +
                activePool.getFeeRecipientClaimableCollShares() +
                totalStipendShares);
    }

    function invariant_GENERAL_05_B(
        CollSurplusPool surplusPool,
        ICollateralToken collateral
    ) internal view returns (bool) {
        return
            collateral.sharesOf(address(surplusPool)) >= (surplusPool.getTotalSurplusCollShares());
    }

    function invariant_GENERAL_06(
        EBTCToken eBTCToken,
        CdpManager cdpManager,
        SortedCdps sortedCdps
    ) internal view returns (bool) {
        uint256 totalSupply = eBTCToken.totalSupply();

        bytes32 currentCdp = sortedCdps.getFirst();
        uint256 cdpsBalance;
        while (currentCdp != bytes32(0)) {
            (uint256 entireDebt, , ) = cdpManager.getDebtAndCollShares(currentCdp);
            cdpsBalance += entireDebt;
            currentCdp = sortedCdps.getNext(currentCdp);
        }

        return totalSupply >= cdpsBalance;
    }

    function invariant_GENERAL_08(
        CdpManager cdpManager,
        SortedCdps sortedCdps,
        PriceFeedTestnet priceFeedTestnet,
        ICollateralToken collateral
    ) internal view returns (bool) {
        uint256 curentPrice = priceFeedTestnet.getPrice();

        bytes32 currentCdp = sortedCdps.getFirst();

        uint256 sumOfColl;
        uint256 sumOfDebt;
        while (currentCdp != bytes32(0)) {
            uint256 entireColl = cdpManager.getSyncedCdpCollShares(currentCdp);
            uint256 entireDebt = cdpManager.getSyncedCdpDebt(currentCdp);
            sumOfColl += entireColl;
            sumOfDebt += entireDebt;
            currentCdp = sortedCdps.getNext(currentCdp);
        }

        uint256 tcrFromSystem = cdpManager.getSyncedTCR(curentPrice);

        uint256 tcrFromSums = LiquityMath._computeCR(
            collateral.getPooledEthByShares(sumOfColl),
            sumOfDebt,
            curentPrice
        );
        /// @audit 1e8 precision
        return isApproximateEq(tcrFromSystem, tcrFromSums, 1e8); // Up to 1e8 precision is accepted
    }

    function invariant_GENERAL_09(
        CdpManager cdpManager,
        Vars memory vars
    ) internal view returns (bool) {
        if (vars.isRecoveryModeBefore) {
            if (vars.cdpDebtAfter > vars.cdpDebtBefore) return (vars.icrAfter > cdpManager.MCR());
            else return true;
        } else {
            return (vars.icrAfter > cdpManager.MCR());
        }
    }

    function invariant_GENERAL_12(
        CdpManager cdpManager,
        PriceFeedTestnet priceFeedMock,
        CRLens crLens
    ) internal returns (bool) {
        uint256 curentPrice = priceFeedMock.getPrice();
        return crLens.quoteRealTCR() == cdpManager.getSyncedTCR(curentPrice);
    }

    function invariant_GENERAL_13(
        CRLens crLens,
        CdpManager cdpManager,
        PriceFeedTestnet priceFeedMock,
        SortedCdps sortedCdps
    ) internal returns (bool) {
        bytes32 currentCdp = sortedCdps.getFirst();

        uint256 _price = priceFeedMock.getPrice();

        // Compare synched with quote for all Cdps
        while (currentCdp != bytes32(0)) {
            uint256 newIcr = crLens.quoteRealICR(currentCdp);
            uint256 synchedICR = cdpManager.getSyncedICR(currentCdp, _price);

            if (newIcr != synchedICR) {
                return false;
            }

            currentCdp = sortedCdps.getNext(currentCdp);
        }
        return true;
    }

    function invariant_GENERAL_14(
        CRLens crLens,
        CdpManager cdpManager,
        SortedCdps sortedCdps
    ) internal returns (bool) {
        bytes32 currentCdp = sortedCdps.getFirst();

        uint256 newIcrPrevious = type(uint256).max;

        // Compare synched with quote for all Cdps
        while (currentCdp != bytes32(0)) {
            uint256 newNICR = crLens.quoteRealNICR(currentCdp);
            uint256 synchedNICR = cdpManager.getSyncedNominalICR(currentCdp); // Uses cached stETH index -> It's not the "real NICR"

            if (newNICR != synchedNICR) {
                return false;
            }

            currentCdp = sortedCdps.getNext(currentCdp);
        }
        return true;
    }

    function invariant_LS_01(
        CdpManager cdpManager,
        LiquidationSequencer ls,
        SyncedLiquidationSequencer syncedLs,
        PriceFeedTestnet priceFeedTestnet
    ) internal returns (bool) {
        // Or just compare max lenght since that's the one with all of them
        uint256 n = cdpManager.getActiveCdpsCount();

        // Get
        uint256 price = priceFeedTestnet.getPrice();

        // Get lists
        bytes32[] memory cdpsFromCurrent = ls.sequenceLiqToBatchLiqWithPrice(n, price);
        bytes32[] memory cdpsSynced = syncedLs.sequenceLiqToBatchLiqWithPrice(n, price);

        uint256 length = cdpsFromCurrent.length;
        if (length != cdpsSynced.length) {
            return false;
        }

        // Compare Lists
        for (uint256 i; i < length; i++) {
            // Find difference = broken
            if (cdpsFromCurrent[i] != cdpsSynced[i]) {
                return false;
            }
        }

        // Implies we're good
        return true;
    }

    function invariant_DUMMY_01(PriceFeedTestnet priceFeedTestnet) internal view returns (bool) {
        return priceFeedTestnet.getPrice() > 0;
    }
}


Lines covered:	0 / 0 (0.0%)

pragma solidity 0.8.17;

abstract contract PropertiesDescriptions {
    ///////////////////////////////////////////////////////
    // Active Pool
    ///////////////////////////////////////////////////////

    string constant AP_01 =
        "AP-01: The collateral balance in the active pool is greater than or equal to its accounting number";
    string constant AP_02 =
        "AP-06: The collateral balance of the ActivePool is positive if there is at least one CDP open";
    string constant AP_03 =
        "AP-03: The eBTC debt accounting number in active pool is greater than or equal to its accounting number";
    string constant AP_04 =
        "AP-04: The total collateral in active pool should be equal to the sum of all individual CDP collateral";
    string constant AP_05 =
        "AP-05: The sum of debt accounting in active pool should be equal to sum of debt accounting of individual CDPs";

    ///////////////////////////////////////////////////////
    // Cdp Manager
    ///////////////////////////////////////////////////////

    string constant CDPM_01 =
        "CDPM-01: The count of active CDPs is equal to the SortedCdp list length";
    string constant CDPM_02 = "CDPM-02: The sum of active CDPs stake is equal to totalStakes";
    string constant CDPM_03 =
        "CDPM-03: The stFeePerUnit tracker for individual CDP is equal to or less than the global variable";
    string constant CDPM_04 = "CDPM-04: The total system value does not decrease during redemptions";
    string constant CDPM_05 = "CDPM-05: Redemptions do not increase the total system debt";
    string constant CDPM_06 = "CDPM-06: Redemptions do not increase the total system debt";

    ///////////////////////////////////////////////////////
    // Collateral Surplus Pool
    ///////////////////////////////////////////////////////

    string constant CSP_01 =
        "CSP-01: The collateral balance in the collSurplus pool is greater than or equal to its accounting number";

    ///////////////////////////////////////////////////////
    // Sorted List
    ///////////////////////////////////////////////////////

    string constant SL_01 =
        "SL-01: The NICR ranking in the sorted list should follow descending order";
    string constant SL_02 =
        "SL-02: The the first(highest) ICR in the sorted list should be greater or equal to TCR (with tolerance due to rounding errors)";
    string constant SL_03 = "SL-03: All CDPs have status active and stake greater than zero";
    string constant SL_05 =
        "SL-05: The CDPs should be sorted in descending order of new ICR (accrued)";

    ///////////////////////////////////////////////////////
    // Borrower Operations
    ///////////////////////////////////////////////////////

    string constant BO_01 = "BO-01: Users can only open CDPs with healthy ICR";
    string constant BO_02 = "BO-02: Users must repay all debt to close a CDP";
    string constant BO_03 = "BO-03: Adding collateral doesn't reduce Nominal ICR";
    string constant BO_04 = "BO-04: Removing collateral does not increase the Nominal ICR";
    string constant BO_05 =
        "BO-05: When a borrower closes their active CDP, the gas compensation is refunded to the user";
    string constant BO_07 = "BO-07: eBTC tokens are burned upon repayment of a CDP's debt";
    string constant BO_08 = "BO-08: TCR must increase after a repayment";

    ///////////////////////////////////////////////////////
    // General
    ///////////////////////////////////////////////////////
    string constant GENERAL_01 =
        "GENERAL-01: After any operation, the system should not enter in Recovery Mode";
    string constant GENERAL_02 =
        "GENERAL-02: The dollar value of the locked stETH exceeds the dollar value of the issued eBTC if TCR is greater than 100%";
    string constant GENERAL_03 =
        "GENERAL-03: CdpManager and BorrowerOperations do not hold value terms of stETH and eBTC unless there are donations";
    string constant GENERAL_05 =
        "GENERAL-05: At all times, the total stETH shares of the system exceeds the deposits if there is no negative rebasing events";
    string constant GENERAL_06 =
        "GENERAL-06: At all times, the total debt is greater than the sum of all debts from all CDPs";
    string constant GENERAL_08 =
        "GENERAL-08: At all times TCR = SUM(COLL)  * price / SUM(DEBT) of all CDPs";
    string constant GENERAL_09 =
        "GENERAL-09: After any operation, the ICR of a CDP must be above the MCR in Normal Mode, and after debt increase in Recovery Mode the ICR must be above the CCR";
    string constant GENERAL_10 = "GENERAL-10: All CDPs should maintain a minimum collateral size";
    string constant GENERAL_11 =
        "GENERAL-11: The TCR pre-computed (TCRNotified) is the same as the one after all calls";
    string constant GENERAL_12 =
        "GENERAL-12: The synchedTCR matches the TCR after accrual (as returned by CrLens)";
    string constant GENERAL_13 =
        "GENERAL-13: The SynchedICR of every CDP in the Linked List Matches the ICR the CDPs will have the call (as returned by CrLens)";
    string constant GENERAL_14 =
        "GENERAL-14: The NominalICR from `getNominalICR` matches `quoteRealNICR` (as returned by CrLens)";

    ///////////////////////////////////////////////////////
    // Redemptions
    ///////////////////////////////////////////////////////

    string constant R_07 = "R-07: TCR should not decrease after redemptions";
    string constant R_08 = "R-08: The user eBTC balance should be used to pay the system debt";

    ///////////////////////////////////////////////////////
    // Liquidations
    ///////////////////////////////////////////////////////

    string constant L_01 =
        "L-01: Liquidation only succeeds if ICR < 110% in Normal Mode, or if ICR < 125% in Recovery Mode";
    string constant L_09 =
        "L-09: Undercollateralized liquidations are also incentivized with the Gas Stipend";
    string constant L_12 = "L-12: TCR must increase after liquidation with no redistributions";
    string constant L_14 =
        "If the RM grace period is set and we're in recovery mode, new actions that keep the system in recovery mode should not change the cooldown timestamp";
    string constant L_15 =
        "L-15: The RM grace period should set if a BO/liquidation/redistribution makes the TCR above CCR";
    string constant L_16 =
        "L-16: The RM grace period should reset if a BO/liquidation/redistribution makes the TCR below CCR";

    ///////////////////////////////////////////////////////
    // eBTC
    ///////////////////////////////////////////////////////

    string constant EBTC_02 =
        "EBTC-02: Any eBTC holder (whether or not they have an active CDP) may redeem their eBTC unless TCR is below MCR";

    ///////////////////////////////////////////////////////
    // Fee Recipient
    ///////////////////////////////////////////////////////

    string constant F_01 = "F-01: `claimFeeRecipientCollShares` allows to claim at any time";
    string constant F_02 = "F-02: Fees From Redemptions are added to `claimFeeRecipientCollShares`";
    string constant F_03 = "F-03: Fees From FlashLoans are sent to the fee Recipient";
    ///////////////////////////////////////////////////////
    // Price Feed
    ///////////////////////////////////////////////////////

    string constant PF_01 = "PF-01: The price feed must never revert";
    string constant PF_02 = "PF-02: The price feed must follow valid status transitions";
    string constant PF_03 = "PF-03: The price feed must never deadlock";
    string constant PF_04 =
        "PF-04: The price feed should never report an outdated price if chainlink is Working";
    string constant PF_05 =
        "PF-05: The price feed should never use the fallback if chainlink is Working";
    string constant PF_06 = "PF-06: The system never tries to use the fallback if it is not set";
}


Lines covered:	199 / 199 (100.0%)

pragma solidity 0.8.17;

import "@crytic/properties/contracts/util/PropertiesConstants.sol";

import "../../Interfaces/ICdpManagerData.sol";
import "../../Dependencies/SafeMath.sol";
import "../../CdpManager.sol";
import "../../LiquidationLibrary.sol";
import "../../BorrowerOperations.sol";
import "../../ActivePool.sol";
import "../../CollSurplusPool.sol";
import "../../SortedCdps.sol";
import "../../HintHelpers.sol";
import "../../FeeRecipient.sol";
import "../testnet/PriceFeedTestnet.sol";
import "../CollateralTokenTester.sol";
import "../EBTCTokenTester.sol";
import "../../Governor.sol";
import "../../EBTCDeployer.sol";

import "./Properties.sol";
import "./Actor.sol";
import "../BaseStorageVariables.sol";

abstract contract TargetContractSetup is BaseStorageVariables, PropertiesConstants {
    using SafeMath for uint;

    bytes4 internal constant BURN_SIG = bytes4(keccak256(bytes("burn(address,uint256)")));

    uint internal numberOfCdps;

    struct CDPChange {
        uint collAddition;
        uint collReduction;
        uint debtAddition;
        uint debtReduction;
    }

    function _setUp() internal {
        defaultGovernance = address(this);
        ebtcDeployer = new EBTCDeployer();

        // Default governance is deployer
        // vm.prank(defaultGovernance);
        collateral = new CollateralTokenTester();

        EBTCDeployer.EbtcAddresses memory addr = ebtcDeployer.getFutureEbtcAddresses();

        {
            bytes memory creationCode;
            bytes memory args;

            // Use EBTCDeployer to deploy all contracts at determistic addresses

            // Authority
            creationCode = type(Governor).creationCode;
            args = abi.encode(address(this));

            authority = Governor(
                ebtcDeployer.deploy(ebtcDeployer.AUTHORITY(), abi.encodePacked(creationCode, args))
            );

            // Liquidation Library
            creationCode = type(LiquidationLibrary).creationCode;
            args = abi.encode(
                addr.borrowerOperationsAddress,
                addr.collSurplusPoolAddress,
                addr.ebtcTokenAddress,
                addr.sortedCdpsAddress,
                addr.activePoolAddress,
                addr.priceFeedAddress,
                address(collateral)
            );

            liqudationLibrary = LiquidationLibrary(
                ebtcDeployer.deploy(
                    ebtcDeployer.LIQUIDATION_LIBRARY(),
                    abi.encodePacked(creationCode, args)
                )
            );

            // CDP Manager
            creationCode = type(CdpManager).creationCode;
            args = abi.encode(
                addr.liquidationLibraryAddress,
                addr.authorityAddress,
                addr.borrowerOperationsAddress,
                addr.collSurplusPoolAddress,
                addr.ebtcTokenAddress,
                addr.sortedCdpsAddress,
                addr.activePoolAddress,
                addr.priceFeedAddress,
                address(collateral)
            );

            cdpManager = CdpManager(
                ebtcDeployer.deploy(ebtcDeployer.CDP_MANAGER(), abi.encodePacked(creationCode, args))
            );

            // Borrower Operations
            creationCode = type(BorrowerOperations).creationCode;
            args = abi.encode(
                addr.cdpManagerAddress,
                addr.activePoolAddress,
                addr.collSurplusPoolAddress,
                addr.priceFeedAddress,
                addr.sortedCdpsAddress,
                addr.ebtcTokenAddress,
                addr.feeRecipientAddress,
                address(collateral)
            );

            borrowerOperations = BorrowerOperations(
                ebtcDeployer.deploy(
                    ebtcDeployer.BORROWER_OPERATIONS(),
                    abi.encodePacked(creationCode, args)
                )
            );

            // Price Feed Mock
            creationCode = type(PriceFeedTestnet).creationCode;
            args = abi.encode(addr.authorityAddress);

            priceFeedMock = PriceFeedTestnet(
                ebtcDeployer.deploy(ebtcDeployer.PRICE_FEED(), abi.encodePacked(creationCode, args))
            );

            // Sorted CDPS
            creationCode = type(SortedCdps).creationCode;
            args = abi.encode(
                type(uint256).max,
                addr.cdpManagerAddress,
                addr.borrowerOperationsAddress
            );

            sortedCdps = SortedCdps(
                ebtcDeployer.deploy(ebtcDeployer.SORTED_CDPS(), abi.encodePacked(creationCode, args))
            );

            // Active Pool
            creationCode = type(ActivePool).creationCode;
            args = abi.encode(
                addr.borrowerOperationsAddress,
                addr.cdpManagerAddress,
                address(collateral),
                addr.collSurplusPoolAddress,
                addr.feeRecipientAddress
            );

            activePool = ActivePool(
                ebtcDeployer.deploy(ebtcDeployer.ACTIVE_POOL(), abi.encodePacked(creationCode, args))
            );

            // Coll Surplus Pool
            creationCode = type(CollSurplusPool).creationCode;
            args = abi.encode(
                addr.borrowerOperationsAddress,
                addr.cdpManagerAddress,
                addr.activePoolAddress,
                address(collateral)
            );

            collSurplusPool = CollSurplusPool(
                ebtcDeployer.deploy(
                    ebtcDeployer.COLL_SURPLUS_POOL(),
                    abi.encodePacked(creationCode, args)
                )
            );

            // Hint Helpers
            creationCode = type(HintHelpers).creationCode;
            args = abi.encode(
                addr.sortedCdpsAddress,
                addr.cdpManagerAddress,
                address(collateral),
                addr.activePoolAddress,
                addr.priceFeedAddress
            );

            hintHelpers = HintHelpers(
                ebtcDeployer.deploy(
                    ebtcDeployer.HINT_HELPERS(),
                    abi.encodePacked(creationCode, args)
                )
            );

            // eBTC Token
            creationCode = type(EBTCTokenTester).creationCode;
            args = abi.encode(
                addr.cdpManagerAddress,
                addr.borrowerOperationsAddress,
                addr.authorityAddress
            );

            eBTCToken = EBTCTokenTester(
                ebtcDeployer.deploy(ebtcDeployer.EBTC_TOKEN(), abi.encodePacked(creationCode, args))
            );

            // Fee Recipieint
            creationCode = type(FeeRecipient).creationCode;
            args = abi.encode(
                addr.ebtcTokenAddress,
                addr.cdpManagerAddress,
                addr.borrowerOperationsAddress,
                addr.activePoolAddress,
                address(collateral)
            );

            feeRecipient = FeeRecipient(
                ebtcDeployer.deploy(
                    ebtcDeployer.FEE_RECIPIENT(),
                    abi.encodePacked(creationCode, args)
                )
            );

            // Configure authority
            authority.setRoleName(0, "Admin");
            authority.setRoleName(1, "eBTCToken: mint");
            authority.setRoleName(2, "eBTCToken: burn");
            authority.setRoleName(3, "CDPManager: all");
            authority.setRoleName(4, "PriceFeed: setTellorCaller");
            authority.setRoleName(5, "BorrowerOperations: all");

            authority.setRoleCapability(1, address(eBTCToken), eBTCToken.mint.selector, true);

            authority.setRoleCapability(2, address(eBTCToken), BURN_SIG, true);

            authority.setRoleCapability(
                3,
                address(cdpManager),
                cdpManager.setStakingRewardSplit.selector,
                true
            );
            authority.setRoleCapability(
                3,
                address(cdpManager),
                cdpManager.setRedemptionFeeFloor.selector,
                true
            );
            authority.setRoleCapability(
                3,
                address(cdpManager),
                cdpManager.setMinuteDecayFactor.selector,
                true
            );
            authority.setRoleCapability(3, address(cdpManager), cdpManager.setBeta.selector, true);
            authority.setRoleCapability(
                3,
                address(cdpManager),
                cdpManager.setGracePeriod.selector,
                true
            );
            authority.setRoleCapability(
                3,
                address(cdpManager),
                cdpManager.setRedemptionsPaused.selector,
                true
            );

            authority.setRoleCapability(
                4,
                address(priceFeedMock),
                priceFeedMock.setFallbackCaller.selector,
                true
            );

            authority.setRoleCapability(
                5,
                address(borrowerOperations),
                borrowerOperations.setFeeBps.selector,
                true
            );
            authority.setRoleCapability(
                5,
                address(borrowerOperations),
                borrowerOperations.setFlashLoansPaused.selector,
                true
            );

            authority.setRoleCapability(5, address(activePool), activePool.setFeeBps.selector, true);
            authority.setRoleCapability(
                5,
                address(activePool),
                activePool.setFlashLoansPaused.selector,
                true
            );
            authority.setRoleCapability(
                5,
                address(activePool),
                activePool.claimFeeRecipientCollShares.selector,
                true
            );

            authority.setUserRole(defaultGovernance, 0, true);
            authority.setUserRole(defaultGovernance, 1, true);
            authority.setUserRole(defaultGovernance, 2, true);
            authority.setUserRole(defaultGovernance, 3, true);
            authority.setUserRole(defaultGovernance, 4, true);
            authority.setUserRole(defaultGovernance, 5, true);

            crLens = new CRLens(address(cdpManager), address(priceFeedMock));

            liquidationSequencer = new LiquidationSequencer(
                address(cdpManager),
                address(cdpManager.sortedCdps()),
                address(priceFeedMock),
                address(activePool),
                address(collateral)
            );
            syncedLiquidationSequencer = new SyncedLiquidationSequencer(
                address(cdpManager),
                address(cdpManager.sortedCdps()),
                address(priceFeedMock),
                address(activePool),
                address(collateral)
            );
        }
    }

    event Log(string);

    function _setUpFork() internal {
        defaultGovernance = address(0xA967Ba66Fb284EC18bbe59f65bcf42dD11BA8128);
        ebtcDeployer = EBTCDeployer(0xe90f99c08F286c48db4D1AfdAE6C122de69B7219);
        collateral = CollateralTokenTester(payable(0xf8017430A0efE03577f6aF88069a21900448A373));
        {
            authority = Governor(0x4945Fc25282b1bC103d2C62C251Cd022138c1de9);
            liqudationLibrary = LiquidationLibrary(0xE8943a17363DE9A6e0d4A5d48d5Ab45283199F77);
            cdpManager = CdpManager(0x0c5C2B93b96C9B3aD7fb9915952BD7BA256C4f04);
            borrowerOperations = BorrowerOperations(0xA178BFBc42E3D886d540CDDcf4562c53a8Fc02c1);
            priceFeedMock = PriceFeedTestnet(0x5C819E5D61EFCfBd7e4635f1112f3bF94663999b);
            sortedCdps = SortedCdps(0xDeFF25eC3cd3041BC8B9A464F9BEc12EB8247Be6);
            activePool = ActivePool(0x55abdfb760dd032627D531f7cF3DAa72549CEbA2);
            collSurplusPool = CollSurplusPool(0x7b4D951D7b8090f62bD009b371abd7Fe04aB7e1A);
            hintHelpers = HintHelpers(0xCaBdBc4218dd4b9E3fB9842232aD0aFc7c431693);
            eBTCToken = EBTCTokenTester(0x9Aa69Db8c53E504EF22615390EE9Eb72cb8bE498);
            feeRecipient = FeeRecipient(0x40FF68eaE525233950B63C2BCEa39770efDE52A4);

            crLens = new CRLens(address(cdpManager), address(priceFeedMock));

            liquidationSequencer = new LiquidationSequencer(
                address(cdpManager),
                address(cdpManager.sortedCdps()),
                address(priceFeedMock),
                address(activePool),
                address(collateral)
            );
        }
    }

    function _setUpActors() internal {
        bool success;
        address[] memory tokens = new address[](2);
        tokens[0] = address(eBTCToken);
        tokens[1] = address(collateral);
        address[] memory callers = new address[](2);
        callers[0] = address(borrowerOperations);
        callers[1] = address(activePool);
        address[] memory addresses = new address[](3);
        addresses[0] = USER1;
        addresses[1] = USER2;
        addresses[2] = USER3;
        for (uint i = 0; i < NUMBER_OF_ACTORS; i++) {
            actors[addresses[i]] = new Actor(tokens, callers);
            (success, ) = address(actors[addresses[i]]).call{value: INITIAL_ETH_BALANCE}("");
            assert(success);
            (success, ) = actors[addresses[i]].proxy(
                address(collateral),
                abi.encodeWithSelector(CollateralTokenTester.deposit.selector, ""),
                INITIAL_COLL_BALANCE
            );
            assert(success);
        }
    }
}


Lines covered:	524 / 593 (88.4%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "@crytic/properties/contracts/util/Hevm.sol";

import "../../Interfaces/ICdpManagerData.sol";
import "../../Dependencies/SafeMath.sol";
import "../../CdpManager.sol";
import "../../LiquidationLibrary.sol";
import "../../BorrowerOperations.sol";
import "../../ActivePool.sol";
import "../../CollSurplusPool.sol";
import "../../SortedCdps.sol";
import "../../HintHelpers.sol";
import "../../FeeRecipient.sol";
import "../testnet/PriceFeedTestnet.sol";
import "../CollateralTokenTester.sol";
import "../EBTCTokenTester.sol";
import "../../Governor.sol";
import "../../EBTCDeployer.sol";

import "./Properties.sol";
import "./Actor.sol";
import "./BeforeAfter.sol";
import "./TargetContractSetup.sol";
import "./Asserts.sol";
import "../BaseStorageVariables.sol";

abstract contract TargetFunctions is Properties {
    modifier setup() virtual {
        actor = actors[msg.sender];
        _;
    }

    ///////////////////////////////////////////////////////
    // Helper functions
    ///////////////////////////////////////////////////////

    function _totalCdpsBelowMcr() internal returns (uint256) {
        uint256 ans;
        bytes32 currentCdp = sortedCdps.getFirst();

        uint256 _price = priceFeedMock.getPrice();

        while (currentCdp != bytes32(0)) {
            if (cdpManager.getICR(currentCdp, _price) < cdpManager.MCR()) {
                ++ans;
            }

            currentCdp = sortedCdps.getNext(currentCdp);
        }

        return ans;
    }

    function _getCdpIdsAndICRs() internal view returns (Cdp[] memory ans) {
        ans = new Cdp[](sortedCdps.getSize());
        uint256 i = 0;
        bytes32 currentCdp = sortedCdps.getFirst();

        uint256 _price = priceFeedMock.getPrice();

        while (currentCdp != bytes32(0)) {
            ans[i++] = Cdp({id: currentCdp, icr: cdpManager.getSyncedICR(currentCdp, _price)}); /// @audit NOTE: Synced to ensure it's realistic

            currentCdp = sortedCdps.getNext(currentCdp);
        }
    }

    function _cdpIdsAndICRsDiff(
        Cdp[] memory superset,
        Cdp[] memory subset
    ) internal returns (Cdp[] memory ans) {
        ans = new Cdp[](superset.length - subset.length);
        uint256 index = 0;
        for (uint256 i = 0; i < superset.length; i++) {
            bool duplicate = false;
            for (uint256 j = 0; j < subset.length; j++) {
                if (superset[i].id == subset[j].id) {
                    duplicate = true;
                }
            }
            if (!duplicate) {
                ans[index++] = superset[i];
            }
        }
    }

    function _getRandomCdp(uint _i) internal view returns (bytes32) {
        uint _cdpIdx = _i % cdpManager.getActiveCdpsCount();
        return cdpManager.CdpIds(_cdpIdx);
    }

    event FlashLoanAction(uint, uint);

    function _getFlashLoanActions(uint256 value) internal returns (bytes memory) {
        uint256 _actions = between(value, 1, MAX_FLASHLOAN_ACTIONS);
        uint256 _EBTCAmount = between(value, 1, eBTCToken.totalSupply() / 2);
        uint256 _col = between(value, 1, cdpManager.getSystemCollShares() / 2);
        uint256 _n = between(value, 1, cdpManager.getActiveCdpsCount());

        uint256 numberOfCdps = sortedCdps.cdpCountOf(address(actor));
        require(numberOfCdps > 0, "Actor must have at least one CDP open");
        uint256 _i = between(value, 0, numberOfCdps - 1);
        bytes32 _cdpId = sortedCdps.cdpOfOwnerByIndex(address(actor), _i);
        t(_cdpId != bytes32(0), "CDP ID must not be null if the index is valid");

        address[] memory _targets = new address[](_actions);
        bytes[] memory _calldatas = new bytes[](_actions);

        address[] memory _allTargets = new address[](6);
        bytes[] memory _allCalldatas = new bytes[](6);

        _allTargets[0] = address(borrowerOperations);
        _allCalldatas[0] = abi.encodeWithSelector(
            BorrowerOperations.openCdp.selector,
            _EBTCAmount,
            bytes32(0),
            bytes32(0),
            _col
        );

        _allTargets[1] = address(borrowerOperations);
        _allCalldatas[1] = abi.encodeWithSelector(BorrowerOperations.closeCdp.selector, _cdpId);

        _allTargets[2] = address(borrowerOperations);
        _allCalldatas[2] = abi.encodeWithSelector(
            BorrowerOperations.addColl.selector,
            _cdpId,
            _cdpId,
            _cdpId,
            _col
        );

        _allTargets[3] = address(borrowerOperations);
        _allCalldatas[3] = abi.encodeWithSelector(
            BorrowerOperations.withdrawColl.selector,
            _cdpId,
            _col,
            _cdpId,
            _cdpId
        );

        _allTargets[4] = address(borrowerOperations);
        _allCalldatas[4] = abi.encodeWithSelector(
            BorrowerOperations.withdrawEBTC.selector,
            _cdpId,
            _EBTCAmount,
            _cdpId,
            _cdpId
        );

        _allTargets[5] = address(borrowerOperations);
        _allCalldatas[5] = abi.encodeWithSelector(
            BorrowerOperations.repayEBTC.selector,
            _cdpId,
            _EBTCAmount,
            _cdpId,
            _cdpId
        );

        for (uint256 _j = 0; _j < _actions; ++_j) {
            _i = uint256(keccak256(abi.encodePacked(value, _j, _i))) % _allTargets.length;
            emit FlashLoanAction(_j, _i);

            _targets[_j] = _allTargets[_i];
            _calldatas[_j] = _allCalldatas[_i];
        }

        return abi.encode(_targets, _calldatas);
    }

    function _getFirstCdpWithIcrGteMcr() internal returns (bytes32) {
        bytes32 _cId = sortedCdps.getLast();
        address currentBorrower = sortedCdps.getOwnerAddress(_cId);
        // Find the first cdp with ICR >= MCR
        while (
            currentBorrower != address(0) &&
            cdpManager.getICR(_cId, priceFeedMock.getPrice()) < cdpManager.MCR()
        ) {
            _cId = sortedCdps.getPrev(_cId);
            currentBorrower = sortedCdps.getOwnerAddress(_cId);
        }
        return _cId;
    }

    function _atLeastOneCdpIsLiquidatable(
        Cdp[] memory cdps,
        bool isRecoveryModeBefore
    ) internal view returns (bool atLeastOneCdpIsLiquidatable) {
        for (uint256 i = 0; i < cdps.length; ++i) {
            if (
                cdps[i].icr < cdpManager.MCR() ||
                (cdps[i].icr < cdpManager.CCR() && isRecoveryModeBefore)
            ) {
                atLeastOneCdpIsLiquidatable = true;
                break;
            }
        }
    }

    ///////////////////////////////////////////////////////
    // CdpManager
    ///////////////////////////////////////////////////////

    function liquidate(uint _i) public setup {
        bool success;
        bytes memory returnData;

        require(cdpManager.getActiveCdpsCount() > 1, "Cannot liquidate last CDP");

        bytes32 _cdpId = _getRandomCdp(_i);

        (uint256 entireDebt, , ) = cdpManager.getDebtAndCollShares(_cdpId);
        require(entireDebt > 0, "CDP must have debt");

        _before(_cdpId);

        (success, returnData) = actor.proxy(
            address(cdpManager),
            abi.encodeWithSelector(CdpManager.liquidate.selector, _cdpId)
        );

        _after(_cdpId);

        if (success) {
            if (
                vars.newIcrBefore >= cdpManager.LICR() // 103% else liquidating locks in bad debt
            ) {
                // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/5
                gte(vars.newTcrAfter, vars.newTcrBefore, L_12);
            }
            // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/12
            t(
                vars.newIcrBefore < cdpManager.MCR() ||
                    (vars.newIcrBefore < cdpManager.CCR() && vars.isRecoveryModeBefore),
                L_01
            );
            if (
                vars.lastGracePeriodStartTimestampIsSetBefore &&
                vars.isRecoveryModeBefore &&
                vars.isRecoveryModeAfter
            ) {
                eq(
                    vars.lastGracePeriodStartTimestampBefore,
                    vars.lastGracePeriodStartTimestampAfter,
                    L_14
                );
            }

            if (!vars.isRecoveryModeBefore && vars.isRecoveryModeAfter) {
                t(
                    !vars.lastGracePeriodStartTimestampIsSetBefore &&
                        vars.lastGracePeriodStartTimestampIsSetAfter,
                    L_15
                );
            }

            if (vars.isRecoveryModeBefore && !vars.isRecoveryModeAfter) {
                t(!vars.lastGracePeriodStartTimestampIsSetAfter, L_16);
            }

            gte(
                vars.actorCollAfter,
                vars.actorCollBefore +
                    collateral.getPooledEthByShares(vars.liquidatorRewardSharesBefore),
                L_09
            );
        } else if (vars.sortedCdpsSizeBefore > _i) {
            assertRevertReasonNotEqual(returnData, "Panic(17)");
        }
    }

    function partialLiquidate(uint _i, uint _partialAmount) public setup {
        bool success;
        bytes memory returnData;

        require(cdpManager.getActiveCdpsCount() > 1, "Cannot liquidate last CDP");

        bytes32 _cdpId = _getRandomCdp(_i);

        (uint256 entireDebt, , ) = cdpManager.getDebtAndCollShares(_cdpId);
        require(entireDebt > 0, "CDP must have debt");

        _partialAmount = between(_partialAmount, 0, entireDebt);

        _before(_cdpId);

        (success, returnData) = actor.proxy(
            address(cdpManager),
            abi.encodeWithSelector(
                CdpManager.partiallyLiquidate.selector,
                _cdpId,
                _partialAmount,
                _cdpId,
                _cdpId
            )
        );

        _after(_cdpId);

        if (success) {
            lt(vars.cdpDebtAfter, vars.cdpDebtBefore, "Partial liquidation must reduce CDP debt");

            if (
                vars.newIcrBefore >= cdpManager.LICR() // 103% else liquidating locks in bad debt
            ) {
                // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/5
                gte(vars.newTcrAfter, vars.newTcrBefore, L_12);
            }
            // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/12
            t(
                vars.newIcrBefore < cdpManager.MCR() ||
                    (vars.newIcrBefore < cdpManager.CCR() && vars.isRecoveryModeBefore),
                L_01
            );

            eq(vars.sortedCdpsSizeAfter, vars.sortedCdpsSizeBefore, "Partial Liquidation CANNOT close CDPs");

            // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/4
            if (vars.sortedCdpsSizeAfter == vars.sortedCdpsSizeBefore) {
                // CDP was not fully liquidated
                gte(
                    collateral.getPooledEthByShares(cdpManager.getCdpCollShares(_cdpId)),
                    borrowerOperations.MIN_NET_COLL(),
                    GENERAL_10
                );
            }

            if (
                vars.lastGracePeriodStartTimestampIsSetBefore &&
                vars.isRecoveryModeBefore &&
                vars.isRecoveryModeAfter
            ) {
                eq(
                    vars.lastGracePeriodStartTimestampBefore,
                    vars.lastGracePeriodStartTimestampAfter,
                    L_14
                );
            }

            if (!vars.isRecoveryModeBefore && vars.isRecoveryModeAfter) {
                t(
                    !vars.lastGracePeriodStartTimestampIsSetBefore &&
                        vars.lastGracePeriodStartTimestampIsSetAfter,
                    L_15
                );
            }

            if (vars.isRecoveryModeBefore && !vars.isRecoveryModeAfter) {
                t(!vars.lastGracePeriodStartTimestampIsSetAfter, L_16);
            }
        } else {
            assertRevertReasonNotEqual(returnData, "Panic(17)");
        }
    }

    function liquidateCdps(uint _n) public setup {
        bool success;
        bytes memory returnData;

        require(cdpManager.getActiveCdpsCount() > 1, "Cannot liquidate last CDP");

        _n = between(_n, 1, cdpManager.getActiveCdpsCount());

        Cdp[] memory cdpsBefore = _getCdpIdsAndICRs();

        _before(bytes32(0));

        bytes32[] memory batch = liquidationSequencer.sequenceLiqToBatchLiqWithPrice(
            _n,
            vars.priceBefore
        );

        (success, returnData) = actor.proxy(
            address(cdpManager),
            abi.encodeWithSelector(CdpManager.batchLiquidateCdps.selector, batch)
        );

        _after(bytes32(0));

        if (success) {
            Cdp[] memory cdpsAfter = _getCdpIdsAndICRs();

            Cdp[] memory cdpsLiquidated = _cdpIdsAndICRsDiff(cdpsBefore, cdpsAfter);
            gte(
                cdpsLiquidated.length,
                1,
                "liquidateCdps must liquidate at least 1 CDP when successful"
            );
            lte(cdpsLiquidated.length, _n, "liquidateCdps must not liquidate more than n CDPs");
            for (uint256 i = 0; i < cdpsLiquidated.length; ++i) {
                // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/12
                t(
                    cdpsLiquidated[i].icr < cdpManager.MCR() ||
                        (cdpsLiquidated[i].icr < cdpManager.CCR() && vars.isRecoveryModeBefore),
                    L_01
                );
            }

            if (
                vars.lastGracePeriodStartTimestampIsSetBefore &&
                vars.isRecoveryModeBefore &&
                vars.isRecoveryModeAfter
            ) {
                eq(
                    vars.lastGracePeriodStartTimestampBefore,
                    vars.lastGracePeriodStartTimestampAfter,
                    L_14
                );
            }

            if (!vars.isRecoveryModeBefore && vars.isRecoveryModeAfter) {
                t(
                    !vars.lastGracePeriodStartTimestampIsSetBefore &&
                        vars.lastGracePeriodStartTimestampIsSetAfter,
                    L_15
                );
            }

            if (vars.isRecoveryModeBefore && !vars.isRecoveryModeAfter) {
                t(!vars.lastGracePeriodStartTimestampIsSetAfter, L_16);
            }
        } else if (vars.sortedCdpsSizeBefore > _n) {
            if (_atLeastOneCdpIsLiquidatable(cdpsBefore, vars.isRecoveryModeBefore)) {
                assertRevertReasonNotEqual(returnData, "Panic(17)");
            }
        }
    }

    function redeemCollateral(
        uint _EBTCAmount,
        uint _partialRedemptionHintNICR,
        uint _maxFeePercentage,
        uint _maxIterations
    ) public setup {
        bool success;
        bytes memory returnData;

        _EBTCAmount = between(_EBTCAmount, 0, eBTCToken.balanceOf(address(actor)));
        _maxIterations = between(_maxIterations, 0, 1);

        _maxFeePercentage = between(
            _maxFeePercentage,
            cdpManager.redemptionFeeFloor(),
            cdpManager.DECIMAL_PRECISION()
        );

        bytes32 _cdpId = _getFirstCdpWithIcrGteMcr();

        _before(_cdpId);

        (success, returnData) = actor.proxy(
            address(cdpManager),
            abi.encodeWithSelector(
                CdpManager.redeemCollateral.selector,
                _EBTCAmount,
                bytes32(0),
                bytes32(0),
                bytes32(0),
                _partialRedemptionHintNICR,
                _maxIterations,
                _maxFeePercentage
            )
        );

        require(success);

        _after(_cdpId);

        gt(vars.tcrBefore, cdpManager.MCR(), EBTC_02);
        if (_maxIterations == 1) {
            gte(vars.activePoolDebtBefore, vars.activePoolDebtAfter, CDPM_05);
            gte(vars.cdpDebtBefore, vars.cdpDebtAfter, CDPM_06);
            // TODO: CHECK THIS
            // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/10#issuecomment-1702685732
            if (vars.sortedCdpsSizeBefore == vars.sortedCdpsSizeAfter) {
                // Redemptions do not reduce TCR
                // If redemptions do not close any CDP that was healthy (low debt, high coll)
                gt(
                    vars.newTcrAfter, // TODO: See how this breaks
                    vars.newTcrBefore,
                    R_07
                );
            }
            t(invariant_CDPM_04(vars), CDPM_04);
        }
        gt(vars.actorEbtcBefore, vars.actorEbtcAfter, R_08);

        // Verify Fee Recipient Received the Fee
        gte(vars.feeRecipientTotalCollAfter, vars.feeRecipientTotalCollBefore, F_02);

        if (
            vars.lastGracePeriodStartTimestampIsSetBefore &&
            vars.isRecoveryModeBefore &&
            vars.isRecoveryModeAfter
        ) {
            eq(
                vars.lastGracePeriodStartTimestampBefore,
                vars.lastGracePeriodStartTimestampAfter,
                L_14
            );
        }

        if (!vars.isRecoveryModeBefore && vars.isRecoveryModeAfter) {
            t(
                !vars.lastGracePeriodStartTimestampIsSetBefore &&
                    vars.lastGracePeriodStartTimestampIsSetAfter,
                L_15
            );
        }

        if (vars.isRecoveryModeBefore && !vars.isRecoveryModeAfter) {
            t(!vars.lastGracePeriodStartTimestampIsSetAfter, L_16);
        }
    }

    ///////////////////////////////////////////////////////
    // ActivePool
    ///////////////////////////////////////////////////////

    function flashLoanColl(uint _amount) internal setup {
        bool success;
        bytes memory returnData;

        _amount = between(_amount, 0, activePool.maxFlashLoan(address(collateral)));
        uint _fee = activePool.flashFee(address(collateral), _amount);

        _before(bytes32(0));

        // take the flashloan which should always cost the fee paid by caller
        uint _balBefore = collateral.balanceOf(activePool.feeRecipientAddress());
        (success, returnData) = actor.proxy(
            address(activePool),
            abi.encodeWithSelector(
                ActivePool.flashLoan.selector,
                IERC3156FlashBorrower(address(actor)),
                address(collateral),
                _amount,
                _getFlashLoanActions(_amount)
            )
        );

        require(success);

        _after(bytes32(0));

        uint _balAfter = collateral.balanceOf(activePool.feeRecipientAddress());
        eq(_balAfter - _balBefore, _fee, F_03);

        if (
            vars.lastGracePeriodStartTimestampIsSetBefore &&
            vars.isRecoveryModeBefore &&
            vars.isRecoveryModeAfter
        ) {
            eq(
                vars.lastGracePeriodStartTimestampBefore,
                vars.lastGracePeriodStartTimestampAfter,
                L_14
            );
        }

        if (!vars.isRecoveryModeBefore && vars.isRecoveryModeAfter) {
            t(
                !vars.lastGracePeriodStartTimestampIsSetBefore &&
                    vars.lastGracePeriodStartTimestampIsSetAfter,
                L_15
            );
        }

        if (vars.isRecoveryModeBefore && !vars.isRecoveryModeAfter) {
            t(!vars.lastGracePeriodStartTimestampIsSetAfter, L_16);
        }
    }

    ///////////////////////////////////////////////////////
    // BorrowerOperations
    ///////////////////////////////////////////////////////

    function flashLoanEBTC(uint _amount) internal setup {
        bool success;
        bytes memory returnData;

        _amount = between(_amount, 0, borrowerOperations.maxFlashLoan(address(eBTCToken)));

        uint _fee = borrowerOperations.flashFee(address(eBTCToken), _amount);

        _before(bytes32(0));

        // take the flashloan which should always cost the fee paid by caller
        uint _balBefore = eBTCToken.balanceOf(borrowerOperations.feeRecipientAddress());
        (success, returnData) = actor.proxy(
            address(borrowerOperations),
            abi.encodeWithSelector(
                BorrowerOperations.flashLoan.selector,
                IERC3156FlashBorrower(address(actor)),
                address(eBTCToken),
                _amount,
                _getFlashLoanActions(_amount)
            )
        );

        // BorrowerOperations.flashLoan may revert due to reentrancy
        require(success);

        _after(bytes32(0));

        uint _balAfter = eBTCToken.balanceOf(borrowerOperations.feeRecipientAddress());
        eq(_balAfter - _balBefore, _fee, F_03);

        if (
            vars.lastGracePeriodStartTimestampIsSetBefore &&
            vars.isRecoveryModeBefore &&
            vars.isRecoveryModeAfter
        ) {
            eq(
                vars.lastGracePeriodStartTimestampBefore,
                vars.lastGracePeriodStartTimestampAfter,
                L_14
            );
        }

        if (!vars.isRecoveryModeBefore && vars.isRecoveryModeAfter) {
            t(
                !vars.lastGracePeriodStartTimestampIsSetBefore &&
                    vars.lastGracePeriodStartTimestampIsSetAfter,
                L_15
            );
        }

        if (vars.isRecoveryModeBefore && !vars.isRecoveryModeAfter) {
            t(!vars.lastGracePeriodStartTimestampIsSetAfter, L_16);
        }
    }

    function openCdp(uint256 _col, uint256 _EBTCAmount) public setup returns (bytes32 _cdpId) {
        bool success;
        bytes memory returnData;

        // we pass in CCR instead of MCR in case it's the first one
        uint price = priceFeedMock.getPrice();

        uint256 requiredCollAmount = (_EBTCAmount * cdpManager.CCR()) / (price);
        uint256 minCollAmount = max(
            cdpManager.MIN_NET_COLL() + borrowerOperations.LIQUIDATOR_REWARD(),
            requiredCollAmount
        );
        uint256 maxCollAmount = min(2 * minCollAmount, INITIAL_COLL_BALANCE / 10);
        _col = between(requiredCollAmount, minCollAmount, maxCollAmount);

        (success, ) = actor.proxy(
            address(collateral),
            abi.encodeWithSelector(
                CollateralTokenTester.approve.selector,
                address(borrowerOperations),
                _col
            )
        );
        t(success, "Approve never fails");

        _before(bytes32(0));

        (success, returnData) = actor.proxy(
            address(borrowerOperations),
            abi.encodeWithSelector(
                BorrowerOperations.openCdp.selector,
                _EBTCAmount,
                bytes32(0),
                bytes32(0),
                _col
            )
        );

        if (success) {
            _cdpId = abi.decode(returnData, (bytes32));
            _after(_cdpId);

            t(invariant_GENERAL_01(vars), GENERAL_01);
            gt(vars.icrAfter, cdpManager.MCR(), BO_01);

            eq(vars.newTcrAfter, vars.tcrAfter, GENERAL_11);

            // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/3
            t(invariant_GENERAL_09(cdpManager, vars), GENERAL_09);
            // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/4
            gte(
                collateral.getPooledEthByShares(cdpManager.getCdpCollShares(_cdpId)),
                borrowerOperations.MIN_NET_COLL(),
                GENERAL_10
            );
            eq(
                vars.sortedCdpsSizeBefore + 1,
                vars.sortedCdpsSizeAfter,
                "CDPs count must have increased"
            );
            if (
                vars.lastGracePeriodStartTimestampIsSetBefore &&
                vars.isRecoveryModeBefore &&
                vars.isRecoveryModeAfter
            ) {
                eq(
                    vars.lastGracePeriodStartTimestampBefore,
                    vars.lastGracePeriodStartTimestampAfter,
                    L_14
                );
            }

            if (!vars.isRecoveryModeBefore && vars.isRecoveryModeAfter) {
                t(
                    !vars.lastGracePeriodStartTimestampIsSetBefore &&
                        vars.lastGracePeriodStartTimestampIsSetAfter,
                    L_15
                );
            }

            if (vars.isRecoveryModeBefore && !vars.isRecoveryModeAfter) {
                t(!vars.lastGracePeriodStartTimestampIsSetAfter, L_16);
            }
        } else {
            assertRevertReasonNotEqual(returnData, "Panic(17)");
        }
    }

    function addColl(uint _coll, uint256 _i) public setup {
        bool success;
        bytes memory returnData;

        uint256 numberOfCdps = sortedCdps.cdpCountOf(address(actor));
        require(numberOfCdps > 0, "Actor must have at least one CDP open");

        _i = between(_i, 0, numberOfCdps - 1);
        bytes32 _cdpId = sortedCdps.cdpOfOwnerByIndex(address(actor), _i);
        t(_cdpId != bytes32(0), "CDP ID must not be null if the index is valid");

        _coll = between(_coll, 0, INITIAL_COLL_BALANCE / 10);

        if (collateral.balanceOf(address(actor)) < _coll) {
            (success, ) = actor.proxy(
                address(collateral),
                abi.encodeWithSelector(CollateralTokenTester.deposit.selector, ""),
                (_coll - collateral.balanceOf(address(actor)))
            );
            require(success);
            require(
                collateral.balanceOf(address(actor)) > _coll,
                "Actor has high enough balance to add"
            );
        }

        (success, ) = actor.proxy(
            address(collateral),
            abi.encodeWithSelector(
                CollateralTokenTester.approve.selector,
                address(borrowerOperations),
                _coll
            )
        );
        t(success, "Approve never fails");

        _before(_cdpId);

        (success, returnData) = actor.proxy(
            address(borrowerOperations),
            abi.encodeWithSelector(
                BorrowerOperations.addColl.selector,
                _cdpId,
                _cdpId,
                _cdpId,
                _coll
            )
        );

        _after(_cdpId);

        if (success) {
            emit L3(
                vars.isRecoveryModeBefore ? 1 : 0,
                vars.hasGracePeriodPassedBefore ? 1 : 0,
                vars.icrAfter
            );
            emit L3(
                block.timestamp,
                cdpManager.lastGracePeriodStartTimestamp(),
                cdpManager.recoveryModeGracePeriod()
            );

            eq(vars.newTcrAfter, vars.tcrAfter, GENERAL_11);
            gte(vars.nicrAfter, vars.nicrBefore, BO_03);
            // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/3
            t(invariant_GENERAL_09(cdpManager, vars), GENERAL_09);
            // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/4
            gte(
                collateral.getPooledEthByShares(cdpManager.getCdpCollShares(_cdpId)),
                borrowerOperations.MIN_NET_COLL(),
                GENERAL_10
            );

            t(invariant_GENERAL_01(vars), GENERAL_01);

            if (
                vars.lastGracePeriodStartTimestampIsSetBefore &&
                vars.isRecoveryModeBefore &&
                vars.isRecoveryModeAfter
            ) {
                eq(
                    vars.lastGracePeriodStartTimestampBefore,
                    vars.lastGracePeriodStartTimestampAfter,
                    L_14
                );
            }

            if (!vars.isRecoveryModeBefore && vars.isRecoveryModeAfter) {
                t(
                    !vars.lastGracePeriodStartTimestampIsSetBefore &&
                        vars.lastGracePeriodStartTimestampIsSetAfter,
                    L_15
                );
            }

            if (vars.isRecoveryModeBefore && !vars.isRecoveryModeAfter) {
                t(!vars.lastGracePeriodStartTimestampIsSetAfter, L_16);
            }
        } else {
            assertRevertReasonNotEqual(returnData, "Panic(17)");
        }
    }

    function withdrawColl(uint _amount, uint256 _i) public setup {
        bool success;
        bytes memory returnData;

        uint256 numberOfCdps = sortedCdps.cdpCountOf(address(actor));
        require(numberOfCdps > 0, "Actor must have at least one CDP open");

        _i = between(_i, 0, numberOfCdps - 1);
        bytes32 _cdpId = sortedCdps.cdpOfOwnerByIndex(address(actor), _i);
        t(_cdpId != bytes32(0), "CDP ID must not be null if the index is valid");

        // Can only withdraw up to CDP collateral amount, otherwise will revert with assert
        _amount = between(
            _amount,
            0,
            collateral.getPooledEthByShares(cdpManager.getCdpCollShares(_cdpId))
        );

        _before(_cdpId);

        (success, returnData) = actor.proxy(
            address(borrowerOperations),
            abi.encodeWithSelector(
                BorrowerOperations.withdrawColl.selector,
                _cdpId,
                _amount,
                _cdpId,
                _cdpId
            )
        );

        _after(_cdpId);

        if (success) {
            eq(vars.newTcrAfter, vars.tcrAfter, GENERAL_11);
            lte(vars.nicrAfter, vars.nicrBefore, BO_04);
            // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/3
            t(invariant_GENERAL_09(cdpManager, vars), GENERAL_09);
            t(invariant_GENERAL_01(vars), GENERAL_01);
            // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/4
            gte(
                collateral.getPooledEthByShares(cdpManager.getCdpCollShares(_cdpId)),
                borrowerOperations.MIN_NET_COLL(),
                GENERAL_10
            );

            if (
                vars.lastGracePeriodStartTimestampIsSetBefore &&
                vars.isRecoveryModeBefore &&
                vars.isRecoveryModeAfter
            ) {
                eq(
                    vars.lastGracePeriodStartTimestampBefore,
                    vars.lastGracePeriodStartTimestampAfter,
                    L_14
                );
            }

            if (!vars.isRecoveryModeBefore && vars.isRecoveryModeAfter) {
                t(
                    !vars.lastGracePeriodStartTimestampIsSetBefore &&
                        vars.lastGracePeriodStartTimestampIsSetAfter,
                    L_15
                );
            }

            if (vars.isRecoveryModeBefore && !vars.isRecoveryModeAfter) {
                t(!vars.lastGracePeriodStartTimestampIsSetAfter, L_16);
            }
        } else {
            assertRevertReasonNotEqual(returnData, "Panic(17)");
        }
    }

    function withdrawEBTC(uint _amount, uint256 _i) public setup {
        bool success;
        bytes memory returnData;

        uint256 numberOfCdps = sortedCdps.cdpCountOf(address(actor));
        require(numberOfCdps > 0, "Actor must have at least one CDP open");

        _i = between(_i, 0, numberOfCdps - 1);
        bytes32 _cdpId = sortedCdps.cdpOfOwnerByIndex(address(actor), _i);
        t(_cdpId != bytes32(0), "CDP ID must not be null if the index is valid");

        // TODO verify the assumption below, maybe there's a more sensible (or Governance-defined/hardcoded) limit for the maximum amount of minted eBTC at a single operation
        // Can only withdraw up to type(uint128).max eBTC, so that `BorrwerOperations._getNewCdpAmounts` does not overflow
        _amount = between(_amount, 0, type(uint128).max);

        _before(_cdpId);

        (success, returnData) = actor.proxy(
            address(borrowerOperations),
            abi.encodeWithSelector(
                BorrowerOperations.withdrawEBTC.selector,
                _cdpId,
                _amount,
                _cdpId,
                _cdpId
            )
        );

        require(success);

        _after(_cdpId);

        eq(vars.newTcrAfter, vars.tcrAfter, GENERAL_11);
        gte(vars.cdpDebtAfter, vars.cdpDebtBefore, "withdrawEBTC must not decrease debt");
        eq(
            vars.actorEbtcAfter,
            vars.actorEbtcBefore + _amount,
            "withdrawEBTC must increase debt by requested amount"
        );
        // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/4
        gte(
            collateral.getPooledEthByShares(cdpManager.getCdpCollShares(_cdpId)),
            borrowerOperations.MIN_NET_COLL(),
            GENERAL_10
        );

        if (
            vars.lastGracePeriodStartTimestampIsSetBefore &&
            vars.isRecoveryModeBefore &&
            vars.isRecoveryModeAfter
        ) {
            eq(
                vars.lastGracePeriodStartTimestampBefore,
                vars.lastGracePeriodStartTimestampAfter,
                L_14
            );
        }

        if (!vars.isRecoveryModeBefore && vars.isRecoveryModeAfter) {
            t(
                !vars.lastGracePeriodStartTimestampIsSetBefore &&
                    vars.lastGracePeriodStartTimestampIsSetAfter,
                L_15
            );
        }

        if (vars.isRecoveryModeBefore && !vars.isRecoveryModeAfter) {
            t(!vars.lastGracePeriodStartTimestampIsSetAfter, L_16);
        }
    }

    function repayEBTC(uint _amount, uint256 _i) public setup {
        bool success;
        bytes memory returnData;

        uint256 numberOfCdps = sortedCdps.cdpCountOf(address(actor));
        require(numberOfCdps > 0, "Actor must have at least one CDP open");

        _i = between(_i, 0, numberOfCdps - 1);
        bytes32 _cdpId = sortedCdps.cdpOfOwnerByIndex(address(actor), _i);
        t(_cdpId != bytes32(0), "CDP ID must not be null if the index is valid");

        (uint256 entireDebt, , ) = cdpManager.getDebtAndCollShares(_cdpId);
        _amount = between(_amount, 0, entireDebt);

        _before(_cdpId);

        (success, returnData) = actor.proxy(
            address(borrowerOperations),
            abi.encodeWithSelector(
                BorrowerOperations.repayEBTC.selector,
                _cdpId,
                _amount,
                _cdpId,
                _cdpId
            )
        );
        require(success);

        _after(_cdpId);

        eq(vars.newTcrAfter, vars.tcrAfter, GENERAL_11);

        // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/3
        gte(vars.newTcrAfter, vars.newTcrBefore, BO_08);

        eq(vars.ebtcTotalSupplyBefore - _amount, vars.ebtcTotalSupplyAfter, BO_07);
        eq(vars.actorEbtcBefore - _amount, vars.actorEbtcAfter, BO_07);
        // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/3
        t(invariant_GENERAL_09(cdpManager, vars), GENERAL_09);
        t(invariant_GENERAL_01(vars), GENERAL_01);
        // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/4
        gte(
            collateral.getPooledEthByShares(cdpManager.getCdpCollShares(_cdpId)),
            borrowerOperations.MIN_NET_COLL(),
            GENERAL_10
        );

        if (
            vars.lastGracePeriodStartTimestampIsSetBefore &&
            vars.isRecoveryModeBefore &&
            vars.isRecoveryModeAfter
        ) {
            eq(
                vars.lastGracePeriodStartTimestampBefore,
                vars.lastGracePeriodStartTimestampAfter,
                L_14
            );
        }

        if (!vars.isRecoveryModeBefore && vars.isRecoveryModeAfter) {
            t(
                !vars.lastGracePeriodStartTimestampIsSetBefore &&
                    vars.lastGracePeriodStartTimestampIsSetAfter,
                L_15
            );
        }

        if (vars.isRecoveryModeBefore && !vars.isRecoveryModeAfter) {
            t(!vars.lastGracePeriodStartTimestampIsSetAfter, L_16);
        }
    }

    function closeCdp(uint _i) public setup {
        bool success;
        bytes memory returnData;

        require(cdpManager.getActiveCdpsCount() > 1, "Cannot close last CDP");

        uint256 numberOfCdps = sortedCdps.cdpCountOf(address(actor));
        require(numberOfCdps > 0, "Actor must have at least one CDP open");

        _i = between(_i, 0, numberOfCdps - 1);
        bytes32 _cdpId = sortedCdps.cdpOfOwnerByIndex(address(actor), _i);
        t(_cdpId != bytes32(0), "CDP ID must not be null if the index is valid");

        _before(_cdpId);

        (success, returnData) = actor.proxy(
            address(borrowerOperations),
            abi.encodeWithSelector(BorrowerOperations.closeCdp.selector, _cdpId)
        );

        _after(_cdpId);

        if (success) {
            eq(vars.newTcrAfter, vars.tcrAfter, GENERAL_11);
            eq(vars.cdpDebtAfter, 0, BO_02);
            eq(
                vars.sortedCdpsSizeBefore - 1,
                vars.sortedCdpsSizeAfter,
                "closeCdp reduces list size by 1"
            );
            gt(
                vars.actorCollAfter,
                vars.actorCollBefore,
                "closeCdp increases the collateral balance of the user"
            );
            // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/3
            t(invariant_GENERAL_09(cdpManager, vars), GENERAL_09);
            emit L4(
                vars.actorCollBefore,
                vars.cdpCollBefore,
                vars.liquidatorRewardSharesBefore,
                vars.actorCollAfter
            );
            gt(
                // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/11
                // Note: not checking for strict equality since split fee is difficult to calculate a-priori, so the CDP collateral value may not be sent back to the user in full
                vars.actorCollAfter,
                vars.actorCollBefore +
                    // ActivePool transfer SHARES not ETH directly
                    collateral.getPooledEthByShares(vars.liquidatorRewardSharesBefore),
                BO_05
            );
            t(invariant_GENERAL_01(vars), GENERAL_01);

            if (
                vars.lastGracePeriodStartTimestampIsSetBefore &&
                vars.isRecoveryModeBefore &&
                vars.isRecoveryModeAfter
            ) {
                eq(
                    vars.lastGracePeriodStartTimestampBefore,
                    vars.lastGracePeriodStartTimestampAfter,
                    L_14
                );
            }

            if (!vars.isRecoveryModeBefore && vars.isRecoveryModeAfter) {
                t(
                    !vars.lastGracePeriodStartTimestampIsSetBefore &&
                        vars.lastGracePeriodStartTimestampIsSetAfter,
                    L_15
                );
            }

            if (vars.isRecoveryModeBefore && !vars.isRecoveryModeAfter) {
                t(!vars.lastGracePeriodStartTimestampIsSetAfter, L_16);
            }
        } else {
            assertRevertReasonNotEqual(returnData, "Panic(17)");
        }
    }

    function adjustCdp(
        uint _i,
        uint _collWithdrawal,
        uint _EBTCChange,
        bool _isDebtIncrease
    ) public setup {
        bool success;
        bytes memory returnData;

        uint256 numberOfCdps = sortedCdps.cdpCountOf(address(actor));
        require(numberOfCdps > 0, "Actor must have at least one CDP open");

        _i = between(_i, 0, numberOfCdps - 1);
        bytes32 _cdpId = sortedCdps.cdpOfOwnerByIndex(address(actor), _i);
        t(_cdpId != bytes32(0), "CDP ID must not be null if the index is valid");

        (uint256 entireDebt, uint256 entireColl, ) = cdpManager.getDebtAndCollShares(_cdpId);
        _collWithdrawal = between(_collWithdrawal, 0, entireColl);
        _EBTCChange = between(_EBTCChange, 0, entireDebt);

        _before(_cdpId);

        (success, returnData) = actor.proxy(
            address(borrowerOperations),
            abi.encodeWithSelector(
                BorrowerOperations.adjustCdp.selector,
                _cdpId,
                _collWithdrawal,
                _EBTCChange,
                _isDebtIncrease,
                _cdpId,
                _cdpId
            )
        );

        require(success);

        _after(_cdpId);

        eq(vars.newTcrAfter, vars.tcrAfter, GENERAL_11);
        // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/3
        t(invariant_GENERAL_09(cdpManager, vars), GENERAL_09);

        t(invariant_GENERAL_01(vars), GENERAL_01);
        // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/4
        gte(
            collateral.getPooledEthByShares(cdpManager.getCdpCollShares(_cdpId)),
            borrowerOperations.MIN_NET_COLL(),
            GENERAL_10
        );

        if (
            vars.lastGracePeriodStartTimestampIsSetBefore &&
            vars.isRecoveryModeBefore &&
            vars.isRecoveryModeAfter
        ) {
            eq(
                vars.lastGracePeriodStartTimestampBefore,
                vars.lastGracePeriodStartTimestampAfter,
                L_14
            );
        }

        if (!vars.isRecoveryModeBefore && vars.isRecoveryModeAfter) {
            t(
                !vars.lastGracePeriodStartTimestampIsSetBefore &&
                    vars.lastGracePeriodStartTimestampIsSetAfter,
                L_15
            );
        }

        if (vars.isRecoveryModeBefore && !vars.isRecoveryModeAfter) {
            t(!vars.lastGracePeriodStartTimestampIsSetAfter, L_16);
        }
    }

    ///////////////////////////////////////////////////////
    // Collateral Token (Test)
    ///////////////////////////////////////////////////////

    // Example for real world slashing: https://twitter.com/LidoFinance/status/1646505631678107649
    // > There are 11 slashing ongoing with the RockLogic GmbH node operator in Lido.
    // > the total projected impact is around 20 ETH,
    // > or about 3% of average daily protocol rewards/0.0004% of TVL.
    function setEthPerShare(uint256 _newEthPerShare) public {
        uint256 currentEthPerShare = collateral.getEthPerShare();
        _newEthPerShare = between(
            _newEthPerShare,
            (currentEthPerShare * 1e18) / MAX_REBASE_PERCENT,
            (currentEthPerShare * MAX_REBASE_PERCENT) / 1e18
        );
        collateral.setEthPerShare(_newEthPerShare);
    }

    ///////////////////////////////////////////////////////
    // PriceFeed
    ///////////////////////////////////////////////////////

    function setPrice(uint256 _newPrice) public {
        uint256 currentPrice = priceFeedMock.getPrice();
        _newPrice = between(
            _newPrice,
            (currentPrice * 1e18) / MAX_PRICE_CHANGE_PERCENT,
            (currentPrice * MAX_PRICE_CHANGE_PERCENT) / 1e18
        );
        priceFeedMock.setPrice(_newPrice);
    }

    ///////////////////////////////////////////////////////
    // Governance
    ///////////////////////////////////////////////////////

    function setGovernanceParameters(uint256 parameter, uint256 value) public {
        parameter = between(parameter, 0, 6);

        if (parameter == 0) {
            value = between(value, cdpManager.MINIMUM_GRACE_PERIOD(), type(uint128).max);
            hevm.prank(defaultGovernance);
            cdpManager.setGracePeriod(uint128(value));
        } else if (parameter == 1) {
            value = between(value, 0, activePool.getFeeRecipientClaimableCollShares());
            hevm.prank(defaultGovernance);
            _before(bytes32(0));
            activePool.claimFeeRecipientCollShares(value);
            _after(bytes32(0));
            // If there was something to claim
            if(value > 0) {
                // Claiming will increase the balance
                gte(vars.feeRecipientCollSharesAfter, vars.feeRecipientCollSharesBefore, F_01);
            }
        } else if (parameter == 2) {
            value = between(value, 0, cdpManager.MAX_REWARD_SPLIT());
            hevm.prank(defaultGovernance);
            cdpManager.setStakingRewardSplit(value);
        } else if (parameter == 3) {
            value = between(
                value,
                cdpManager.MIN_REDEMPTION_FEE_FLOOR(),
                cdpManager.DECIMAL_PRECISION()
            );
            hevm.prank(defaultGovernance);
            cdpManager.setRedemptionFeeFloor(value);
        } else if (parameter == 4) {
            value = between(
                value,
                cdpManager.MIN_MINUTE_DECAY_FACTOR(),
                cdpManager.MAX_MINUTE_DECAY_FACTOR()
            );
            hevm.prank(defaultGovernance);
            cdpManager.setMinuteDecayFactor(value);
        } else if (parameter == 5) {
            value = between(value, 0, cdpManager.DECIMAL_PRECISION());
            hevm.prank(defaultGovernance);
            cdpManager.setBeta(value);
        } else if (parameter == 6) {
            value = between(value, 0, 1);
            hevm.prank(defaultGovernance);
            cdpManager.setRedemptionsPaused(value == 1 ? true : false);
        }
    }
}


Lines covered:	8 / 8 (100.0%)

pragma solidity 0.8.17;

import "@crytic/properties/contracts/util/PropertiesHelper.sol";
import "../Asserts.sol";

abstract contract EchidnaAsserts is PropertiesAsserts, Asserts {
    function gt(uint256 a, uint256 b, string memory message) internal override {
        assertGt(a, b, message);
    }

    function lt(uint256 a, uint256 b, string memory message) internal override {
        assertLt(a, b, message);
    }

    function gte(uint256 a, uint256 b, string memory message) internal override {
        assertGte(a, b, message);
    }

    function lte(uint256 a, uint256 b, string memory message) internal override {
        assertLte(a, b, message);
    }

    function eq(uint256 a, uint256 b, string memory message) internal override {
        assertEq(a, b, message);
    }

    function t(bool a, string memory message) internal override {
        assertWithMsg(a, message);
    }

    function between(uint256 value, uint256 low, uint256 high) internal override returns (uint256) {
        return clampBetween(value, low, high);
    }
}


Lines covered:	54 / 54 (100.0%)

pragma solidity 0.8.17;

import {TargetContractSetup} from "../TargetContractSetup.sol";
import {Properties} from "../Properties.sol";

abstract contract EchidnaProperties is TargetContractSetup, Properties {
    function echidna_price() public returns (bool) {
        return invariant_DUMMY_01(priceFeedMock);
    }

    function echidna_active_pool_invariant_1() public returns (bool) {
        return invariant_AP_01(collateral, activePool);
    }

    function echidna_active_pool_invariant_2() public returns (bool) {
        return invariant_AP_02(cdpManager, activePool);
    }

    function echidna_active_pool_invariant_3() public returns (bool) {
        return invariant_AP_03(eBTCToken, activePool);
    }

    function echidna_active_pool_invariant_4() public returns (bool) {
        return invariant_AP_04(cdpManager, activePool, diff_tolerance);
    }

    function echidna_active_pool_invariant_5() public returns (bool) {
        return invariant_AP_05(cdpManager, diff_tolerance);
    }

    function echidna_cdp_manager_invariant_1() public returns (bool) {
        return invariant_CDPM_01(cdpManager, sortedCdps);
    }

    function echidna_cdp_manager_invariant_2() public returns (bool) {
        return invariant_CDPM_02(cdpManager);
    }

    function echidna_cdp_manager_invariant_3() public returns (bool) {
        return invariant_CDPM_03(cdpManager);
    }

    // CDPM_04 is a vars invariant

    function echidna_coll_surplus_pool_invariant_1() public returns (bool) {
        return invariant_CSP_01(collateral, collSurplusPool);
    }

    function echidna_coll_surplus_pool_invariant_2() public returns (bool) {
        return invariant_CSP_02(collSurplusPool);
    }

    function echidna_sorted_list_invariant_1() public returns (bool) {
        return invariant_SL_01(cdpManager, sortedCdps);
    }

    function echidna_sorted_list_invariant_2() public returns (bool) {
        return invariant_SL_02(cdpManager, sortedCdps, priceFeedMock);
    }

    function echidna_sorted_list_invariant_3() public returns (bool) {
        return invariant_SL_03(cdpManager, priceFeedMock, sortedCdps);
    }

    // https://github.com/Badger-Finance/ebtc-fuzz-review/issues/15
    function echidna_sorted_list_invariant_5() public returns (bool) {
        return invariant_SL_05(crLens, sortedCdps);
    }

    // invariant_GENERAL_01 is a vars invariant

    function echidna_GENERAL_02() public returns (bool) {
        return invariant_GENERAL_02(cdpManager, priceFeedMock, eBTCToken);
    }

    function echidna_GENERAL_03() public returns (bool) {
        return invariant_GENERAL_03(cdpManager, borrowerOperations, eBTCToken, collateral);
    }

    function echidna_GENERAL_05() public returns (bool) {
        return invariant_GENERAL_05(activePool, cdpManager, collateral);
    }

    function echidna_GENERAL_05_B() public returns (bool) {
        return invariant_GENERAL_05_B(collSurplusPool, collateral);
    }

    function echidna_GENERAL_06() public returns (bool) {
        return invariant_GENERAL_06(eBTCToken, cdpManager, sortedCdps);
    }

    function echidna_GENERAL_08() public returns (bool) {
        return invariant_GENERAL_08(cdpManager, sortedCdps, priceFeedMock, collateral);
    }

    // invariant_GENERAL_09 is a vars

    function echidna_GENERAL_12() public returns (bool) {
        return invariant_GENERAL_12(cdpManager, priceFeedMock, crLens);
    }

    function echidna_GENERAL_13() public returns (bool) {
        return invariant_GENERAL_13(crLens, cdpManager, priceFeedMock, sortedCdps);
    }

    function echidna_GENERAL_14() public returns (bool) {
        return invariant_GENERAL_14(crLens, cdpManager, sortedCdps);
    }

    function echidna_LS_01() public returns (bool) {
        return
            invariant_LS_01(
                cdpManager,
                liquidationSequencer,
                syncedLiquidationSequencer,
                priceFeedMock
            );
    }
}


Lines covered:	3 / 3 (100.0%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "./EchidnaAsserts.sol";
import "./EchidnaProperties.sol";
import "../TargetFunctions.sol";

contract EchidnaTester is EchidnaAsserts, EchidnaProperties, TargetFunctions {
    constructor() payable {
        _setUp();
        _setUpActors();
    }
}


Lines covered:	11 / 35 (31.4%)

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "../../Interfaces/IPriceFeed.sol";
import "../../Interfaces/IFallbackCaller.sol";
import "../../Dependencies/Ownable.sol";
import "../../Dependencies/AuthNoOwner.sol";

/*
 * PriceFeed placeholder for testnet and development. The price can be manually input or fetched from
   the Fallback's TestNet implementation. Backwards compatible with local test environment as it defaults to use
   the manual price.
 */
contract PriceFeedTestnet is IPriceFeed, Ownable, AuthNoOwner {
    // --- variables ---

    uint256 private _price = 7428 * 1e13; // stETH/BTC price == ~15.8118 ETH per BTC
    bool public _useFallback;
    IFallbackCaller public fallbackCaller; // Wrapper contract that calls the Fallback system

    constructor(address _authorityAddress) {
        _initializeAuthority(_authorityAddress);
    }

    // --- Dependency setters ---

    function setAddresses(
        address _priceAggregatorAddress, // Not used but kept for compatibility with deployment script
        address _fallbackCallerAddress,
        address _authorityAddress
    ) external onlyOwner {
        fallbackCaller = IFallbackCaller(_fallbackCallerAddress);

        _initializeAuthority(_authorityAddress);

        renounceOwnership();
    }

    // --- Functions ---

    // View price getter for simplicity in tests
    function getPrice() external view returns (uint256) {
        return _price;
    }

    function fetchPrice() external override returns (uint256) {
        // Fire an event just like the mainnet version would.
        // This lets the subgraph rely on events to get the latest price even when developing locally.
        if (_useFallback) {
            FallbackResponse memory fallbackResponse = _getCurrentFallbackResponse();
            if (fallbackResponse.success) {
                _price = fallbackResponse.answer;
            }
        }
        emit LastGoodPriceUpdated(_price);
        return _price;
    }

    // Manual external price setter.
    function setPrice(uint256 price) external returns (bool) {
        _price = price;
        return true;
    }

    // Manual toggle use of Tellor testnet feed
    function toggleUseFallback() external returns (bool) {
        _useFallback = !_useFallback;
        return _useFallback;
    }

    function setFallbackCaller(address _fallbackCaller) external requiresAuth {
        address oldFallbackCaller = address(fallbackCaller);
        fallbackCaller = IFallbackCaller(_fallbackCaller);
        emit FallbackCallerChanged(oldFallbackCaller, _fallbackCaller);
    }

    // --- Oracle response wrapper functions ---
    /*
     * "_getCurrentFallbackResponse" fetches stETH/BTC from the Fallback, and returns it as a
     * FallbackResponse struct.
     */
    function _getCurrentFallbackResponse()
        internal
        view
        returns (FallbackResponse memory fallbackResponse)
    {
        uint256 stEthBtcValue;
        uint256 stEthBtcTimestamp;
        bool stEthBtcRetrieved;

        // Attempt to get the Fallback's stETH/BTC price
        try fallbackCaller.getFallbackResponse() returns (
            uint256 answer,
            uint256 timestampRetrieved,
            bool success
        ) {
            fallbackResponse.answer = answer;
            fallbackResponse.timestamp = timestampRetrieved;
            fallbackResponse.success = success;
        } catch {
            return (fallbackResponse);
        }
        return (fallbackResponse);
    }
}


Lines covered:	1 / 1 (100.0%)

// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

interface IHevm {
    // Set block.timestamp to newTimestamp
    function warp(uint256 newTimestamp) external;

    // Set block.number to newNumber
    function roll(uint256 newNumber) external;

    // Loads a storage slot from an address
    function load(address where, bytes32 slot) external returns (bytes32);

    // Stores a value to an address' storage slot
    function store(address where, bytes32 slot, bytes32 value) external;

    // Signs data (privateKey, digest) => (r, v, s)
    function sign(uint256 privateKey, bytes32 digest) external returns (uint8 r, bytes32 v, bytes32 s);

    // Gets address for a given private key
    function addr(uint256 privateKey) external returns (address addr);

    // Performs a foreign function call via terminal
    function ffi(string[] calldata inputs) external returns (bytes memory result);
    
    // Performs the next smart contract call with specified `msg.sender`
    function prank(address newSender) external;
}

IHevm constant hevm = IHevm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);

Lines covered:	3 / 3 (100.0%)

pragma solidity ^0.8.0;

abstract contract PropertiesConstants {
    // Constant echidna addresses
    address constant USER1 = address(0x10000);
    address constant USER2 = address(0x20000);
    address constant USER3 = address(0x30000);
    uint256 constant INITIAL_BALANCE = 1000e18;
}


Lines covered:	41 / 57 (71.9%)

pragma solidity ^0.8.0;

abstract contract PropertiesAsserts {
    event LogUint256(string,uint256);
    event LogAddress(string, address);
    event LogString(string);

    event AssertFail(string);
    event AssertEqFail(string);
    event AssertNeqFail(string);
    event AssertGteFail(string);
    event AssertGtFail(string);
    event AssertLteFail(string);
    event AssertLtFail(string);

    function assertWithMsg(bool b, string memory reason) internal {
        if(!b){
            emit AssertFail(reason);
            assert(false);
        }
    }

    /// @notice asserts that a is equal to b. Violations are logged using reason.
    function assertEq(uint256 a, uint256 b, string memory reason) internal {
        if(a != b){
            string memory aStr = PropertiesLibString.toString(a);
            string memory bStr = PropertiesLibString.toString(b);
            bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr,"!=",bStr,", reason: ", reason);
            emit AssertEqFail(string(assertMsg));
            assert(false);
        }
    }

    /// @notice int256 version of assertEq
    function assertEq(int256 a, int256 b, string memory reason) internal {
        if(a != b){
            string memory aStr = PropertiesLibString.toString(a);
            string memory bStr = PropertiesLibString.toString(b);
            bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr,"!=",bStr,", reason: ", reason);
            emit AssertEqFail(string(assertMsg));
            assert(false);
        }
    }

    /// @notice asserts that a is not equal to b. Violations are logged using reason.
    function assertNeq(uint256 a, uint256 b, string memory reason) internal {
        if(a == b){
            string memory aStr = PropertiesLibString.toString(a);
            string memory bStr = PropertiesLibString.toString(b);
            bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr,"==",bStr,", reason: ", reason);
            emit AssertNeqFail(string(assertMsg));
            assert(false);
        }
    }

    /// @notice int256 version of assertNeq
    function assertNeq(int256 a, int256 b, string memory reason) internal {
        if(a == b){
            string memory aStr = PropertiesLibString.toString(a);
            string memory bStr = PropertiesLibString.toString(b);
            bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr,"==",bStr,", reason: ", reason);
            emit AssertNeqFail(string(assertMsg));
            assert(false);
        }
    }

    /// @notice asserts that a is greater than or equal to b. Violations are logged using reason.
    function assertGte(uint256 a, uint256 b, string memory reason) internal {
        if(!(a >= b)) {
            string memory aStr = PropertiesLibString.toString(a);
            string memory bStr = PropertiesLibString.toString(b);
            bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr,"<",bStr," failed, reason: ", reason);
            emit AssertGteFail(string(assertMsg));
            assert(false);
        }
    }

    /// @notice int256 version of assertGte
    function assertGte(int256 a, int256 b, string memory reason) internal {
        if(!(a >= b)) {
            string memory aStr = PropertiesLibString.toString(a);
            string memory bStr = PropertiesLibString.toString(b);
            bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr,"<",bStr," failed, reason: ", reason);
            emit AssertGteFail(string(assertMsg));
            assert(false);
        }
    }

    /// @notice asserts that a is greater than b. Violations are logged using reason.
    function assertGt(uint256 a, uint256 b, string memory reason) internal {
        if(!(a > b)) {
            string memory aStr = PropertiesLibString.toString(a);
            string memory bStr = PropertiesLibString.toString(b);
            bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr,"<=", bStr," failed, reason: ", reason);
            emit AssertGtFail(string(assertMsg));
            assert(false);
        }
    }

    /// @notice int256 version of assertGt
    function assertGt(int256 a, int256 b, string memory reason) internal {
        if(!(a > b)) {
            string memory aStr = PropertiesLibString.toString(a);
            string memory bStr = PropertiesLibString.toString(b);
            bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr,"<=", bStr," failed, reason: ", reason);
            emit AssertGtFail(string(assertMsg));
            assert(false);
        }
    }

    /// @notice asserts that a is less than or equal to b. Violations are logged using reason.
    function assertLte(uint256 a, uint256 b, string memory reason) internal {
        if(!(a <= b)) {
            string memory aStr = PropertiesLibString.toString(a);
            string memory bStr = PropertiesLibString.toString(b);
            bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr,">", bStr," failed, reason: ", reason);
            emit AssertLteFail(string(assertMsg));
            assert(false);
        }
    }

    /// @notice int256 version of assertLte
    function assertLte(int256 a, int256 b, string memory reason) internal {
        if(!(a <= b)) {
            string memory aStr = PropertiesLibString.toString(a);
            string memory bStr = PropertiesLibString.toString(b);
            bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr,">", bStr," failed, reason: ", reason);
            emit AssertLteFail(string(assertMsg));
            assert(false);
        }
    }

    /// @notice asserts that a is less than b. Violations are logged using reason.
    function assertLt(uint256 a, uint256 b, string memory reason) internal {
        if(!(a < b)) {
            string memory aStr = PropertiesLibString.toString(a);
            string memory bStr = PropertiesLibString.toString(b);
            bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr,">=",bStr," failed, reason: ", reason);
            emit AssertLtFail(string(assertMsg));
            assert(false);
        }
    }

    /// @notice int256 version of assertLt
    function assertLt(int256 a, int256 b, string memory reason) internal {
        if(!(a < b)) {
            string memory aStr = PropertiesLibString.toString(a);
            string memory bStr = PropertiesLibString.toString(b);
            bytes memory assertMsg = abi.encodePacked("Invalid: ", aStr,">=",bStr," failed, reason: ", reason);
            emit AssertLtFail(string(assertMsg));
            assert(false);
        }
    }

    /// @notice Clamps value to be between low and high, both inclusive
    function clampBetween(uint256 value, uint256 low, uint256 high) internal returns (uint256) {
        if(value < low || value > high) {
            uint ans = low + (value % (high - low + 1));
            string memory valueStr = PropertiesLibString.toString(value);
            string memory ansStr = PropertiesLibString.toString(ans);
            bytes memory message = abi.encodePacked("Clamping value ", valueStr, " to ", ansStr);
            emit LogString(string(message));
            return ans;
        }
        return value;
    }

    /// @notice int256 version of clampBetween
    function clampBetween(int256 value, int256 low, int256 high) internal returns (int256) {
        if(value < low || value > high) {
            int range = high - low + 1;
            int clamped = (value - low) % (range);
            if (clamped < 0) clamped += range;
            int ans = low + clamped;
            string memory valueStr = PropertiesLibString.toString(value);
            string memory ansStr = PropertiesLibString.toString(ans);
            bytes memory message = abi.encodePacked("Clamping value ", valueStr, " to ", ansStr);
            emit LogString(string(message));
            return ans;
        }
        return value;
    }

    /// @notice clamps a to be less than b
    function clampLt(uint256 a, uint256 b) internal returns (uint256){
        if ( !(a < b)) {
            assertNeq(b, 0, "clampLt cannot clamp value a to be less than zero. Check your inputs/assumptions.");
            uint256 value = a % b;
            string memory aStr = PropertiesLibString.toString(a);
            string memory valueStr = PropertiesLibString.toString(value);
            bytes memory message = abi.encodePacked("Clamping value ", aStr, " to ", valueStr);
            emit LogString(string(message));
            return value;
        }
        return a;
    }

    /// @notice int256 version of clampLt
    function clampLt(int256 a, int256 b) internal returns (int256){
        if ( !(a < b)) {
            int256 value = b-1;
            string memory aStr = PropertiesLibString.toString(a);
            string memory valueStr = PropertiesLibString.toString(value);
            bytes memory message = abi.encodePacked("Clamping value ", aStr, " to ", valueStr);
            emit LogString(string(message));
            return value;
        }
        return a;
    }

    /// @notice clamps a to be less than or equal to b
    function clampLte(uint256 a, uint256 b) internal returns (uint256) {
        if(!(a <= b)) {
            uint256 value = a % (b+1);
            string memory aStr = PropertiesLibString.toString(a);
            string memory valueStr = PropertiesLibString.toString(value);
            bytes memory message = abi.encodePacked("Clamping value ", aStr, " to ", valueStr);
            emit LogString(string(message));
            return value;
        }
        return a;
    }

    /// @notice int256 version of clampLte
    function clampLte(int256 a, int256 b) internal returns (int256) {
        if(!(a <= b)) {
            int256 value = b;
            string memory aStr = PropertiesLibString.toString(a);
            string memory valueStr = PropertiesLibString.toString(value);
            bytes memory message = abi.encodePacked("Clamping value ", aStr, " to ", valueStr);
            emit LogString(string(message));
            return value;
        }
        return a;
    }

    /// @notice clamps a to be greater than b
    function clampGt(uint256 a, uint256 b) internal returns (uint256) {
        if(!(a > b)){
            assertNeq(b, type(uint256).max, "clampGt cannot clamp value a to be larger than uint256.max. Check your inputs/assumptions.");
            uint256 value = b+1;
            string memory aStr = PropertiesLibString.toString(a);
            string memory valueStr = PropertiesLibString.toString(value);
            bytes memory message = abi.encodePacked("Clamping value ", aStr, " to ", valueStr);
            emit LogString(string(message));
            return value;
        } else {
            return a;
        }
    }

    /// @notice int256 version of clampGt
    function clampGt(int256 a, int256 b) internal returns (int256) {
        if(!(a > b)){
            int256 value = b+1;
            string memory aStr = PropertiesLibString.toString(a);
            string memory valueStr = PropertiesLibString.toString(value);
            bytes memory message = abi.encodePacked("Clamping value ", aStr, " to ", valueStr);
            emit LogString(string(message));
            return value;
        } else {
            return a;
        }
    }

    /// @notice clamps a to be greater than or equal to b
    function clampGte(uint256 a, uint256 b) internal returns (uint256) {
        if(!(a > b)){
            uint256 value = b;
            string memory aStr = PropertiesLibString.toString(a);
            string memory valueStr = PropertiesLibString.toString(value);
            bytes memory message = abi.encodePacked("Clamping value ", aStr, " to ", valueStr);
            emit LogString(string(message));
            return value;
        }
        return a;
    }

    /// @notice int256 version of clampGte
    function clampGte(int256 a, int256 b) internal returns (int256) {
        if(!(a > b)){
            int256 value = b;
            string memory aStr = PropertiesLibString.toString(a);
            string memory valueStr = PropertiesLibString.toString(value);
            bytes memory message = abi.encodePacked("Clamping value ", aStr, " to ", valueStr);
            emit LogString(string(message));
            return value;
        }
        return a;
    }
}

/// @notice Efficient library for creating string representations of integers.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)
/// @author Modified from Solady (https://github.com/Vectorized/solady/blob/main/src/utils/LibString.sol)
/// @dev Name of the library is modified to prevent collisions with contract-under-test uses of LibString
library PropertiesLibString {

    function toString(int256 value) internal pure returns (string memory str) {
        uint256 absValue = value >= 0 ? uint256(value) : uint256(-value);
        str = toString(absValue);

        if(value < 0) {
            str = string(abi.encodePacked("-", str));
        }
    }

    function toString(uint256 value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit), but we allocate 160 bytes
            // to keep the free memory pointer word aligned. We'll need 1 word for the length, 1 word for the
            // trailing zeros padding, and 3 other words for a max of 78 digits. In total: 5 * 32 = 160 bytes.
            let newFreeMemoryPointer := add(mload(0x40), 160)

            // Update the free memory pointer to avoid overriding our string.
            mstore(0x40, newFreeMemoryPointer)

            // Assign str to the end of the zone of newly allocated memory.
            str := sub(newFreeMemoryPointer, 32)

            // Clean the last word of memory it may not be overwritten.
            mstore(str, 0)

            // Cache the end of the memory to calculate the length later.
            let end := str

            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            // prettier-ignore
            for { let temp := value } 1 {} {
                // Move the pointer 1 byte to the left.
                str := sub(str, 1)

                // Write the character to the pointer.
                // The ASCII index of the '0' character is 48.
                mstore8(str, add(48, mod(temp, 10)))

                // Keep dividing temp until zero.
                temp := div(temp, 10)

                 // prettier-ignore
                if iszero(temp) { break }
            }

            // Compute and cache the final total length of the string.
            let length := sub(end, str)

            // Move the pointer 32 bytes leftwards to make room for the length.
            str := sub(str, 32)

            // Store the string's length at the start of memory allocated for our string.
            mstore(str, length)
        }
    }

    function toString(address value) internal pure returns (string memory str){
        bytes memory s = new bytes(40);
        for (uint i = 0; i < 20; i++) {
            bytes1 b = bytes1(uint8(uint(uint160(value)) / (2**(8*(19 - i)))));
            bytes1 hi = bytes1(uint8(b) / 16);
            bytes1 lo = bytes1(uint8(b) - 16 * uint8(hi));
            s[2*i] = char(hi);
            s[2*i+1] = char(lo);            
        }
        return string(s);
    }

    function char(bytes1 b) internal pure returns (bytes1 c) {
        if (uint8(b) < 10) return bytes1(uint8(b) + 0x30);
        else return bytes1(uint8(b) + 0x57);
    }
}


1			// SPDX-License-Identifier: MIT
2
3			pragma solidity 0.8.17;
4
5			import "./Interfaces/IActivePool.sol";
6			import "./Interfaces/ICollSurplusPool.sol";
7			import "./Dependencies/ICollateralToken.sol";
8			import "./Interfaces/ICdpManagerData.sol";
9			import "./Dependencies/ERC3156FlashLender.sol";
10			import "./Dependencies/SafeERC20.sol";
11			import "./Dependencies/ReentrancyGuard.sol";
12			import "./Dependencies/AuthNoOwner.sol";
13			import "./Dependencies/BaseMath.sol";
14
15			/**
16			* The Active Pool holds the collateral and EBTC debt (but not EBTC tokens) for all active cdps.
17			*
18			* When a cdp is liquidated, it's collateral and EBTC debt are transferred from the Active Pool, to either the
19			* Stability Pool, the Default Pool, or both, depending on the liquidation conditions.
20			*/
21			contract ActivePool is IActivePool, ERC3156FlashLender, ReentrancyGuard, BaseMath, AuthNoOwner {
22			using SafeERC20 for IERC20;
23			string public constant NAME = "ActivePool";
24
25			address public immutable borrowerOperationsAddress;
26			address public immutable cdpManagerAddress;
27			address public immutable collSurplusPoolAddress;
28	√	⟳	address public feeRecipientAddress;
29
30			uint256 internal systemCollShares; // deposited collateral tracker
31			uint256 internal systemDebt;
32			uint256 internal feeRecipientCollShares; // coll shares claimable by fee recipient
33			ICollateralToken public collateral;
34
35			// --- Contract setters ---
36
37			/// @notice Constructor for the ActivePool contract
38			/// @dev Initializes the contract with the borrowerOperationsAddress, cdpManagerAddress, collateral token address, collSurplusAddress, and feeRecipientAddress
39			/// @param _borrowerOperationsAddress The address of the Borrower Operations contract
40			/// @param _cdpManagerAddress The address of the Cdp Manager contract
41			/// @param _collTokenAddress The address of the collateral token
42			/// @param _collSurplusAddress The address of the collateral surplus pool
43			/// @param _feeRecipientAddress The address of the fee recipient
44
45			constructor(
46			address _borrowerOperationsAddress,
47			address _cdpManagerAddress,
48			address _collTokenAddress,
49			address _collSurplusAddress,
50			address _feeRecipientAddress
51			) {
52	√		borrowerOperationsAddress = _borrowerOperationsAddress;
53	√		cdpManagerAddress = _cdpManagerAddress;
54	√		collateral = ICollateralToken(_collTokenAddress);
55	√		collSurplusPoolAddress = _collSurplusAddress;
56	√		feeRecipientAddress = _feeRecipientAddress;
57
58			// TEMP: read authority to avoid signature change
59	√		address _authorityAddress = address(AuthNoOwner(cdpManagerAddress).authority());
60	√		if (_authorityAddress != address(0)) {
61	√		_initializeAuthority(_authorityAddress);
62			}
63
64	√		emit FeeRecipientAddressChanged(_feeRecipientAddress);
65			}
66
67			// --- Getters for public variables. Required by IPool interface ---
68
69			/// @notice Amount of stETH collateral shares in the contract
70			/// @dev Not necessarily equal to the the contract's raw systemCollShares balance - tokens can be forcibly sent to contracts
71			/// @return uint256 The amount of systemCollShares allocated to the pool
72
73	√	⟳	function getSystemCollShares() external view override returns (uint256) {
74	√	⟳	return systemCollShares;
75			}
76
77			/// @notice Returns the systemDebt state variable
78			/// @dev The amount of EBTC debt in the pool. Like systemCollShares, this is not necessarily equal to the contract's EBTC token balance - tokens can be forcibly sent to contracts
79			/// @return uint256 The amount of EBTC debt in the pool
80
81	√	⟳	function getSystemDebt() external view override returns (uint256) {
82	√	⟳	return systemDebt;
83			}
84
85			/// @notice The amount of stETH collateral shares claimable by the fee recipient
86			/// @return uint256 The amount of collateral shares claimable by the fee recipient
87
88	√	⟳	function getFeeRecipientClaimableCollShares() external view override returns (uint256) {
89	√	⟳	return feeRecipientCollShares;
90			}
91
92			// --- Pool functionality ---
93
94			/// @notice Sends stETH collateral shares to a specified account
95			/// @dev Only for use by system contracts, the caller must be either BorrowerOperations or CdpManager
96			/// @param _account The address of the account to send stETH to
97			/// @param _shares The amount of stETH shares to send
98
99			function transferSystemCollShares(address _account, uint256 _shares) public override {
100	√	⟳	_requireCallerIsBOorCdpM();
101
102	√	⟳	uint256 cachedSystemCollShares = systemCollShares;
103	√	⟳	require(cachedSystemCollShares >= _shares, "!ActivePoolBal");
104			unchecked {
105			// Can use unchecked due to above
106	√	⟳	cachedSystemCollShares -= _shares; // Updating here avoids an SLOAD
107			}
108
109	√	⟳	systemCollShares = cachedSystemCollShares;
110
111	√	⟳	emit SystemCollSharesUpdated(cachedSystemCollShares);
112	√	⟳	emit CollSharesTransferred(_account, _shares);
113
114	√	⟳	_transferCollSharesWithContractHooks(_account, _shares);
115			}
116
117			/// @notice Sends stETH to a specified account, drawing from both core shares and liquidator rewards shares
118			/// @notice Liquidator reward shares are not tracked via internal accounting in the active pool and are assumed to be present in expected amount as part of the intended behavior of BorowerOperations and CdpManager
119			/// @dev Liquidator reward shares are added when a cdp is opened, and removed when it is closed
120			/// @dev closeCdp() or liqudations result in the actor (borrower or liquidator respectively) receiving the liquidator reward shares
121			/// @dev Redemptions result in the shares being sent to the coll surplus pool for claiming by the CDP owner
122			/// @dev Note that funds in the coll surplus pool, just like liquidator reward shares, are not tracked as part of the system CR or coll of a CDP.
123			/// @dev Requires that the caller is either BorrowerOperations or CdpManager
124			/// @param _account The address of the account to send systemCollShares and the liquidator reward to
125			/// @param _shares The amount of systemCollShares to send
126			/// @param _liquidatorRewardShares The amount of the liquidator reward shares to send
127
128			function transferSystemCollSharesAndLiquidatorReward(
129			address _account,
130			uint256 _shares,
131			uint256 _liquidatorRewardShares
132			) external override {
133	√	⟳	_requireCallerIsBOorCdpM();
134
135	√	⟳	uint256 cachedSystemCollShares = systemCollShares;
136	√	⟳	require(cachedSystemCollShares >= _shares, "ActivePool: Insufficient collateral shares");
137	√	⟳	uint256 totalShares = _shares + _liquidatorRewardShares; // TODO: Is this safe?
138			unchecked {
139			// Safe per the check above
140	√	⟳	cachedSystemCollShares -= _shares;
141			}
142	√	⟳	systemCollShares = cachedSystemCollShares;
143
144	√	⟳	emit SystemCollSharesUpdated(cachedSystemCollShares);
145	√	⟳	emit CollSharesTransferred(_account, totalShares);
146
147	√	⟳	_transferCollSharesWithContractHooks(_account, totalShares);
148			}
149
150			/// @notice Allocate stETH shares from the system to the fee recipient to claim at-will (pull model)
151			/// @dev Requires that the caller is CdpManager
152			/// @dev Only the current fee recipient address is able to claim the shares
153			/// @dev If the fee recipient address is changed while outstanding claimable coll is available, only the new fee recipient will be able to claim the outstanding coll
154			/// @param _shares The amount of systemCollShares to allocate to the fee recipient
155
156			function allocateSystemCollSharesToFeeRecipient(uint256 _shares) external override {
157	√	⟳	_requireCallerIsCdpManager();
158
159	√	⟳	uint256 cachedSystemCollShares = systemCollShares;
160
161	√	⟳	require(cachedSystemCollShares >= _shares, "ActivePool: Insufficient collateral shares");
162			unchecked {
163			// Safe per the check above
164	√	⟳	cachedSystemCollShares -= _shares;
165			}
166
167	√	⟳	systemCollShares = cachedSystemCollShares;
168
169	√	⟳	uint256 cachedFeeRecipientCollShares = feeRecipientCollShares + _shares;
170	√	⟳	feeRecipientCollShares = cachedFeeRecipientCollShares;
171
172	√	⟳	emit SystemCollSharesUpdated(cachedSystemCollShares);
173	√	⟳	emit FeeRecipientClaimableCollSharesIncreased(cachedFeeRecipientCollShares, _shares);
174			}
175
176			/// @notice Helper function to transfer stETH shares to another address, ensuring to call hooks into other system pools if they are the recipient
177			/// @param _account The address to transfer shares to
178			/// @param _shares The amount of shares to transfer
179
180			function _transferCollSharesWithContractHooks(address _account, uint256 _shares) internal {
181			// NOTE: No need for safe transfer if the collateral asset is standard. Make sure this is the case!
182	√	⟳	collateral.transferShares(_account, _shares);
183
184	√	⟳	if (_account == collSurplusPoolAddress) {
185	√	⟳	ICollSurplusPool(_account).increaseTotalSurplusCollShares(_shares);
186			}
187			}
188
189			/// @notice Increases the tracked EBTC debt of the system by a specified amount
190			/// @dev Managed by system contracts - requires that the caller is either BorrowerOperations or CdpManager
191			/// @param _amount: The amount to increase the system EBTC debt by
192
193			function increaseSystemDebt(uint256 _amount) external override {
194	√		_requireCallerIsBOorCdpM();
195
196	√		uint256 cachedSystemDebt = systemDebt + _amount;
197
198	√		systemDebt = cachedSystemDebt;
199	√		emit ActivePoolEBTCDebtUpdated(cachedSystemDebt);
200			}
201
202			/// @notice Decreases the tracked EBTC debt of the system by a specified amount
203			/// @dev Managed by system contracts - requires that the caller is either BorrowerOperations or CdpManager
204			/// @param _amount: The amount to decrease the system EBTC debt by
205
206			function decreaseSystemDebt(uint256 _amount) external override {
207	√	⟳	_requireCallerIsBOorCdpM();
208
209	√	⟳	uint256 cachedSystemDebt = systemDebt - _amount;
210
211	√	⟳	systemDebt = cachedSystemDebt;
212	√	⟳	emit ActivePoolEBTCDebtUpdated(cachedSystemDebt);
213			}
214
215			// --- 'require' functions ---
216
217			/// @notice Checks if the caller is BorrowerOperations
218			function _requireCallerIsBorrowerOperations() internal view {
219			require(
220	√		msg.sender == borrowerOperationsAddress,
221			"ActivePool: Caller is not BorrowerOperations"
222			);
223			}
224
225			/// @notice Checks if the caller is either BorrowerOperations or CdpManager
226			function _requireCallerIsBOorCdpM() internal view {
227			require(
228	√	⟳	msg.sender == borrowerOperationsAddress \|\| msg.sender == cdpManagerAddress,
229			"ActivePool: Caller is neither BorrowerOperations nor CdpManager"
230			);
231			}
232
233			/// @notice Checks if the caller is CdpManager
234			function _requireCallerIsCdpManager() internal view {
235	√	⟳	require(msg.sender == cdpManagerAddress, "ActivePool: Caller is not CdpManager");
236			}
237
238			/// @notice Notify that stETH collateral shares have been recieved, updating internal accounting accordingly
239			/// @param _value The amount of collateral to receive
240
241			function increaseSystemCollShares(uint256 _value) external override {
242	√		_requireCallerIsBorrowerOperations();
243
244	√		uint256 cachedSystemCollShares = systemCollShares + _value;
245	√		systemCollShares = cachedSystemCollShares;
246	√		emit SystemCollSharesUpdated(cachedSystemCollShares);
247			}
248
249			// === Flashloans === //
250
251			/// @notice Borrow assets with a flash loan
252			/// @dev The Collateral checks may cause reverts if you trigger a fee change big enough
253			/// consider calling `cdpManagerAddress.syncGlobalAccountingAndGracePeriod()`
254			/// @param receiver The address to receive the flash loan
255			/// @param token The address of the token to loan
256			/// @param amount The amount of tokens to loan
257			/// @param data Additional data
258			/// @return A boolean value indicating whether the operation was successful
259
260			function flashLoan(
261			IERC3156FlashBorrower receiver,
262			address token,
263			uint256 amount,
264			bytes calldata data
265			) external override returns (bool) {
266			require(amount > 0, "ActivePool: 0 Amount");
267			uint256 fee = flashFee(token, amount); // NOTE: Check for `token` is implicit in the requires above // also checks for paused
268			require(amount <= maxFlashLoan(token), "ActivePool: Too much");
269
270			uint256 amountWithFee = amount + fee;
271			uint256 oldRate = collateral.getPooledEthByShares(DECIMAL_PRECISION);
272
273			collateral.transfer(address(receiver), amount);
274
275			// Callback
276			require(
277			receiver.onFlashLoan(msg.sender, token, amount, fee, data) == FLASH_SUCCESS_VALUE,
278			"ActivePool: IERC3156: Callback failed"
279			);
280
281			// Transfer of (principal + Fee) from flashloan receiver
282			collateral.transferFrom(address(receiver), address(this), amountWithFee);
283
284			// Send earned fee to designated recipient
285			collateral.transfer(feeRecipientAddress, fee);
286
287			// Check new balance
288			// NOTE: Invariant Check, technically breaks CEI but I think we must use it
289			// NOTE: This means any balance > systemCollShares is stuck, this is also present in LUSD as is
290
291			// NOTE: This check effectively prevents running 2 FL at the same time
292			// You technically could, but you'd be having to repay any amount below systemCollShares to get Fl2 to not revert
293			require(
294			collateral.balanceOf(address(this)) >= collateral.getPooledEthByShares(systemCollShares),
295			"ActivePool: Must repay Balance"
296			);
297			require(
298			collateral.sharesOf(address(this)) >= systemCollShares,
299			"ActivePool: Must repay Share"
300			);
301			require(
302			collateral.getPooledEthByShares(DECIMAL_PRECISION) == oldRate,
303			"ActivePool: Should keep same collateral share rate"
304			);
305
306			emit FlashLoanSuccess(address(receiver), token, amount, fee);
307
308			return true;
309			}
310
311			/// @notice Calculate the flash loan fee for a given token and amount loaned
312			/// @param token The address of the token to calculate the fee for
313			/// @param amount The amount of tokens to calculate the fee for
314			/// @return The amount of the flash loan fee
315
316			function flashFee(address token, uint256 amount) public view override returns (uint256) {
317			require(token == address(collateral), "ActivePool: collateral Only");
318			require(!flashLoansPaused, "ActivePool: Flash Loans Paused");
319
320			return (amount * feeBps) / MAX_BPS;
321			}
322
323			/// @notice Get the maximum flash loan amount for a specific token
324			/// @dev Exclusively used here for stETH collateral, equal to the current balance of the pool
325			/// @param token The address of the token to get the maximum flash loan amount for
326			/// @return The maximum flash loan amount for the token
327			function maxFlashLoan(address token) public view override returns (uint256) {
328			if (token != address(collateral)) {
329			return 0;
330			}
331
332			if (flashLoansPaused) {
333			return 0;
334			}
335
336			return collateral.balanceOf(address(this));
337			}
338
339			// === Governed Functions === //
340
341			/// @notice Claim outstanding shares for fee recipient, updating internal accounting and transferring the shares.
342			/// @dev Call permissinos are managed via authority for flexibility, rather than gating call to just feeRecipient.
343			/// @dev Is likely safe as an open permission though caution should be taken.
344			/// @param _shares The amount of shares to claim to feeRecipient
345			function claimFeeRecipientCollShares(uint256 _shares) external override requiresAuth {
346	√	⟳	ICdpManagerData(cdpManagerAddress).syncGlobalAccountingAndGracePeriod(); // Calling this increases shares so do it first
347
348	√	⟳	uint256 cachedFeeRecipientCollShares = feeRecipientCollShares;
349			require(
350	√	⟳	cachedFeeRecipientCollShares >= _shares,
351			"ActivePool: Insufficient fee recipient coll"
352			);
353
354			unchecked {
355	√	⟳	cachedFeeRecipientCollShares -= _shares;
356			}
357
358	√	⟳	feeRecipientCollShares = cachedFeeRecipientCollShares;
359	√	⟳	emit FeeRecipientClaimableCollSharesDecreased(cachedFeeRecipientCollShares, _shares);
360
361	√	⟳	collateral.transferShares(feeRecipientAddress, _shares);
362			}
363
364			/// @dev Function to move unintended dust that are not protected
365			/// @notice moves given amount of given token (collateral is NOT allowed)
366			/// @notice because recipient are fixed, this function is safe to be called by anyone
367
368			function sweepToken(address token, uint256 amount) public nonReentrant requiresAuth {
369			ICdpManagerData(cdpManagerAddress).syncGlobalAccountingAndGracePeriod(); // Accrue State First
370
371			require(token != address(collateral), "ActivePool: Cannot Sweep Collateral");
372
373			uint256 balance = IERC20(token).balanceOf(address(this));
374			require(amount <= balance, "ActivePool: Attempt to sweep more than balance");
375
376			address cachedFeeRecipientAddress = feeRecipientAddress; // Saves an SLOAD
377
378			IERC20(token).safeTransfer(cachedFeeRecipientAddress, amount);
379
380			emit SweepTokenSuccess(token, amount, cachedFeeRecipientAddress);
381			}
382
383			/// @notice Set new FeeRecipient
384			/// @dev Previous fees are forfeited, if you wish to claim to previous address
385			/// call `claimFeeRecipientCollShares` first
386			function setFeeRecipientAddress(address _feeRecipientAddress) external requiresAuth {
387			ICdpManagerData(cdpManagerAddress).syncGlobalAccountingAndGracePeriod(); // Accrue State First
388
389			require(
390			_feeRecipientAddress != address(0),
391			"ActivePool: Cannot set fee recipient to zero address"
392			);
393
394			feeRecipientAddress = _feeRecipientAddress;
395			emit FeeRecipientAddressChanged(_feeRecipientAddress);
396			}
397
398			/// @notice Sets new Fee for FlashLoans
399			function setFeeBps(uint256 _newFee) external requiresAuth {
400			ICdpManagerData(cdpManagerAddress).syncGlobalAccountingAndGracePeriod(); // Accrue State First
401
402			require(_newFee <= MAX_FEE_BPS, "ERC3156FlashLender: _newFee should <= MAX_FEE_BPS");
403
404			// set new flash fee
405			uint256 _oldFee = feeBps;
406			feeBps = uint16(_newFee);
407			emit FlashFeeSet(msg.sender, _oldFee, _newFee);
408			}
409
410			/// @notice Should Flashloans be paused?
411			function setFlashLoansPaused(bool _paused) external requiresAuth {
412			ICdpManagerData(cdpManagerAddress).syncGlobalAccountingAndGracePeriod(); // Accrue State First
413
414			flashLoansPaused = _paused;
415			emit FlashLoansPaused(msg.sender, _paused);
416			}
417			}
418

1			// SPDX-License-Identifier: MIT
2
3			pragma solidity 0.8.17;
4
5			import "./Interfaces/IPriceFeed.sol";
6			import "./Interfaces/ICdpManager.sol";
7
8			/// @notice The contract allows to check real CR of CDPs
9			/// Acknowledgement: https://github.com/Uniswap/v3-periphery/blob/main/contracts/lens/Quoter.sol
10			contract CRLens {
11			ICdpManager public immutable cdpManager;
12			IPriceFeed public immutable priceFeed;
13
14			constructor(address _cdpManager, address _priceFeed) {
15	√		cdpManager = ICdpManager(_cdpManager);
16	√		priceFeed = IPriceFeed(_priceFeed);
17			}
18
19			// == CORE FUNCTIONS == //
20
21			/// @notice Returns the TCR of the system after the fee split
22			/// @dev Call this from offChain with `eth_call` to avoid paying for gas
23		⟳	function getRealTCR(bool revertValue) external returns (uint256) {
24			// Synch State
25		⟳	cdpManager.syncGlobalAccountingAndGracePeriod();
26
27			// Return latest
28		⟳	uint price = priceFeed.fetchPrice();
29		⟳	uint256 tcr = cdpManager.getTCR(price);
30
31		⟳	if (revertValue) {
32			assembly {
33		⟳	let ptr := mload(0x40)
34		⟳	mstore(ptr, tcr)
35		⟳	revert(ptr, 32)
36			}
37			}
38
39			return tcr;
40			}
41
42			/// @notice Return the ICR of a CDP after the fee split
43			/// @dev Call this from offChain with `eth_call` to avoid paying for gas
44		⟳	function getRealICR(bytes32 cdpId, bool revertValue) external returns (uint256) {
45		⟳	cdpManager.syncAccounting(cdpId);
46		⟳	uint price = priceFeed.fetchPrice();
47		⟳	uint256 icr = cdpManager.getICR(cdpId, price);
48
49		⟳	if (revertValue) {
50			assembly {
51		⟳	let ptr := mload(0x40)
52		⟳	mstore(ptr, icr)
53		⟳	revert(ptr, 32)
54			}
55			}
56
57			return icr;
58			}
59
60			/// @notice Return the ICR of a CDP after the fee split
61			/// @dev Call this from offChain with `eth_call` to avoid paying for gas
62		⟳	function getRealNICR(bytes32 cdpId, bool revertValue) external returns (uint256) {
63		⟳	cdpManager.syncAccounting(cdpId);
64		⟳	uint price = priceFeed.fetchPrice();
65		⟳	uint256 icr = cdpManager.getNominalICR(cdpId);
66
67		⟳	if (revertValue) {
68			assembly {
69		⟳	let ptr := mload(0x40)
70		⟳	mstore(ptr, icr)
71		⟳	revert(ptr, 32)
72			}
73			}
74
75			return icr;
76			}
77
78			/// @dev Returns 1 if we're in RM
79		⟳	function getCheckRecoveryMode(bool revertValue) external returns (uint256) {
80			// Synch State
81		⟳	cdpManager.syncGlobalAccountingAndGracePeriod();
82
83			// Return latest
84		⟳	uint price = priceFeed.fetchPrice();
85		⟳	uint256 isRm = cdpManager.checkRecoveryMode(price) == true ? 1 : 0;
86
87		⟳	if (revertValue) {
88			assembly {
89		⟳	let ptr := mload(0x40)
90		⟳	mstore(ptr, isRm)
91		⟳	revert(ptr, 32)
92			}
93			}
94
95			return isRm;
96			}
97
98			// == REVERT LOGIC == //
99			// Thanks to: https://github.com/Uniswap/v3-periphery/blob/main/contracts/lens/Quoter.sol
100			// NOTE: You should never use these in prod, these are just for testing //
101
102	√	⟳	function parseRevertReason(bytes memory reason) private pure returns (uint256) {
103	√	⟳	if (reason.length != 32) {
104			if (reason.length < 68) revert("Unexpected error");
105			assembly {
106			reason := add(reason, 0x04)
107			}
108			revert(abi.decode(reason, (string)));
109			}
110	√	⟳	return abi.decode(reason, (uint256));
111			}
112
113			/// @notice Returns the TCR of the system after the fee split
114			/// @dev Call this from offChain with `eth_call` to avoid paying for gas
115			/// These cost more gas, there should never be a reason for you to use them beside integration with Echidna
116	√	⟳	function quoteRealTCR() external returns (uint256) {
117	√	⟳	try this.getRealTCR(true) {} catch (bytes memory reason) {
118	√	⟳	return parseRevertReason(reason);
119			}
120			}
121
122			/// @notice Returns the ICR of the system after the fee split
123			/// @dev Call this from offChain with `eth_call` to avoid paying for gas
124			/// These cost more gas, there should never be a reason for you to use them beside integration with Echidna
125	√	⟳	function quoteRealICR(bytes32 cdpId) external returns (uint256) {
126	√	⟳	try this.getRealICR(cdpId, true) {} catch (bytes memory reason) {
127	√	⟳	return parseRevertReason(reason);
128			}
129			}
130
131			/// @notice Returns the NICR of the system after the fee split
132			/// @dev Call this from offChain with `eth_call` to avoid paying for gas
133			/// These cost more gas, there should never be a reason for you to use them beside integration with Echidna
134	√	⟳	function quoteRealNICR(bytes32 cdpId) external returns (uint256) {
135	√	⟳	try this.getRealNICR(cdpId, true) {} catch (bytes memory reason) {
136	√	⟳	return parseRevertReason(reason);
137			}
138			}
139
140			/// @notice Returns whether the system is in RM after taking fee split
141			/// @dev Call this from offChain with `eth_call` to avoid paying for gas
142			/// These cost more gas, there should never be a reason for you to use them beside integration with Echidna
143	√	⟳	function quoteCheckRecoveryMode() external returns (uint256) {
144	√	⟳	try this.getCheckRecoveryMode(true) {} catch (bytes memory reason) {
145	√	⟳	return parseRevertReason(reason);
146			}
147			}
148			}
149

1			// SPDX-License-Identifier: MIT
2			// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
3
4			pragma solidity 0.8.17;
5
6			/**
7			* @dev Collection of functions related to the address type
8			*/
9			library Address {
10			/**
11			* @dev Returns true if `account` is a contract.
12			*
13			* [IMPORTANT]
14			* ====
15			* It is unsafe to assume that an address for which this function returns
16			* false is an externally-owned account (EOA) and not a contract.
17			*
18			* Among others, `isContract` will return false for the following
19			* types of addresses:
20			*
21			* - an externally-owned account
22			* - a contract in construction
23			* - an address where a contract will be created
24			* - an address where a contract lived, but was destroyed
25			*
26			* Furthermore, `isContract` will also return true if the target contract within
27			* the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
28			* which only has an effect at the end of a transaction.
29			* ====
30			*
31			* [IMPORTANT]
32			* ====
33			* You shouldn't rely on `isContract` to protect against flash loan attacks!
34			*
35			* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
36			* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
37			* constructor.
38			* ====
39			*/
40			function isContract(address account) internal view returns (bool) {
41			// This method relies on extcodesize/address.code.length, which returns 0
42			// for contracts in construction, since the code is only stored at the end
43			// of the constructor execution.
44
45			return account.code.length > 0;
46			}
47
48			/**
49			* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
50			* `errorMessage` as a fallback revert reason when `target` reverts.
51			*
52			* _Available since v3.1._
53			*/
54			function functionCall(
55			address target,
56			bytes memory data,
57			string memory errorMessage
58			) internal returns (bytes memory) {
59			return functionCallWithValue(target, data, 0, errorMessage);
60			}
61
62			/**
63			* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
64			* with `errorMessage` as a fallback revert reason when `target` reverts.
65			*
66			* _Available since v3.1._
67			*/
68			function functionCallWithValue(
69			address target,
70			bytes memory data,
71			uint256 value,
72			string memory errorMessage
73			) internal returns (bytes memory) {
74			require(address(this).balance >= value, "Address: insufficient balance for call");
75			(bool success, bytes memory returndata) = target.call{value: value}(data);
76			return verifyCallResultFromTarget(target, success, returndata, errorMessage);
77			}
78
79			/**
80			* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
81			* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
82			*
83			* _Available since v4.8._
84			*/
85			function verifyCallResultFromTarget(
86			address target,
87			bool success,
88			bytes memory returndata,
89			string memory errorMessage
90			) internal view returns (bytes memory) {
91			if (success) {
92			if (returndata.length == 0) {
93			// only check isContract if the call was successful and the return data is empty
94			// otherwise we already know that it was a contract
95			require(isContract(target), "Address: call to non-contract");
96			}
97			return returndata;
98			} else {
99			_revert(returndata, errorMessage);
100			}
101			}
102
103			function _revert(bytes memory returndata, string memory errorMessage) private pure {
104			// Look for revert reason and bubble it up if present
105			if (returndata.length > 0) {
106			// The easiest way to bubble the revert reason is using memory via assembly
107			/// @solidity memory-safe-assembly
108			assembly {
109			let returndata_size := mload(returndata)
110			revert(add(32, returndata), returndata_size)
111			}
112			} else {
113			revert(errorMessage);
114			}
115			}
116			}
117

1		// SPDX-License-Identifier: AGPL-3.0-only
2		pragma solidity 0.8.17;
3
4		import {Authority} from "./Authority.sol";
5
6		/// @notice Provides a flexible and updatable auth pattern which is completely separate from application logic.
7		/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Auth.sol)
8		/// @author Modified from Dappsys (https://github.com/dapphub/ds-auth/blob/master/src/auth.sol)
9		abstract contract Auth {
10		event OwnershipTransferred(address indexed user, address indexed newOwner);
11
12		event AuthorityUpdated(address indexed user, Authority indexed newAuthority);
13
14		address public owner;
15
16		Authority public authority;
17
18		constructor(address _owner, Authority _authority) {
19	√	owner = _owner;
20	√	authority = _authority;
21
22	√	emit OwnershipTransferred(msg.sender, _owner);
23	√	emit AuthorityUpdated(msg.sender, _authority);
24		}
25
26		modifier requiresAuth() virtual {
27	√	require(isAuthorized(msg.sender, msg.sig), "Auth: UNAUTHORIZED");
28
29		_;
30		}
31
32	√	function isAuthorized(address user, bytes4 functionSig) internal view virtual returns (bool) {
33	√	Authority auth = authority; // Memoizing authority saves us a warm SLOAD, around 100 gas.
34
35		// Checking if the caller is the owner only after calling the authority saves gas in most cases, but be
36		// aware that this makes protected functions uncallable even to the owner if the authority is out of order.
37		return
38	√	(address(auth) != address(0) && auth.canCall(user, address(this), functionSig)) \|\|
39	√	user == owner;
40		}
41
42		function setAuthority(Authority newAuthority) public virtual {
43		// We check if the caller is the owner first because we want to ensure they can
44		// always swap out the authority even if it's reverting or using up a lot of gas.
45		require(msg.sender == owner \|\| authority.canCall(msg.sender, address(this), msg.sig));
46
47		authority = newAuthority;
48
49		emit AuthorityUpdated(msg.sender, newAuthority);
50		}
51
52		function transferOwnership(address newOwner) public virtual requiresAuth {
53		owner = newOwner;
54
55		emit OwnershipTransferred(msg.sender, newOwner);
56		}
57		}
58

1			// SPDX-License-Identifier: AGPL-3.0-only
2			pragma solidity 0.8.17;
3
4			/// @notice A generic interface for a contract which provides authorization data to an Auth instance.
5			/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Auth.sol)
6			/// @author Modified from Dappsys (https://github.com/dapphub/ds-auth/blob/master/src/auth.sol)
7			interface Authority {
8			function canCall(address user, address target, bytes4 functionSig) external view returns (bool);
9			}
10

1			// SPDX-License-Identifier: MIT
2			pragma solidity 0.8.17;
3
4			contract BaseMath {
5	√	⟳	uint256 public constant DECIMAL_PRECISION = 1e18;
6			}
7

1		// SPDX-License-Identifier: MIT
2		// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
3
4		pragma solidity 0.8.17;
5
6		/**
7		* @dev Provides information about the current execution context, including the
8		* sender of the transaction and its data. While these are generally available
9		* via msg.sender and msg.data, they should not be accessed in such a direct
10		* manner, since when dealing with meta-transactions the account sending and
11		* paying for execution may not be the actual sender (as far as an application
12		* is concerned).
13		*
14		* This contract is only required for intermediate, library-like contracts.
15		*/
16		abstract contract Context {
17	√	function _msgSender() internal view virtual returns (address) {
18	√	return msg.sender;
19		}
20
21		function _msgData() internal view virtual returns (bytes calldata) {
22		return msg.data;
23		}
24		}
25

1		//SPDX-License-Identifier: Unlicense
2		pragma solidity 0.8.17;
3
4		/**
5		@title A library for deploying contracts EIP-3171 style.
6		@author Agustin Aguilar <aa@horizon.io>
7		*/
8		library Create3 {
9		error ErrorCreatingProxy();
10		error ErrorCreatingContract();
11		error TargetAlreadyExists();
12
13		/**
14		@notice The bytecode for a contract that proxies the creation of another contract
15		@dev If this code is deployed using CREATE2 it can be used to decouple `creationCode` from the child contract address
16
17		0x67363d3d37363d34f03d5260086018f3:
18		0x00 0x67 0x67XXXXXXXXXXXXXXXX PUSH8 bytecode 0x363d3d37363d34f0
19		0x01 0x3d 0x3d RETURNDATASIZE 0 0x363d3d37363d34f0
20		0x02 0x52 0x52 MSTORE
21		0x03 0x60 0x6008 PUSH1 08 8
22		0x04 0x60 0x6018 PUSH1 18 24 8
23		0x05 0xf3 0xf3 RETURN
24
25		0x363d3d37363d34f0:
26		0x00 0x36 0x36 CALLDATASIZE cds
27		0x01 0x3d 0x3d RETURNDATASIZE 0 cds
28		0x02 0x3d 0x3d RETURNDATASIZE 0 0 cds
29		0x03 0x37 0x37 CALLDATACOPY
30		0x04 0x36 0x36 CALLDATASIZE cds
31		0x05 0x3d 0x3d RETURNDATASIZE 0 cds
32		0x06 0x34 0x34 CALLVALUE val 0 cds
33		0x07 0xf0 0xf0 CREATE addr
34		*/
35
36		bytes internal constant PROXY_CHILD_BYTECODE =
37		hex"67_36_3d_3d_37_36_3d_34_f0_3d_52_60_08_60_18_f3";
38
39		// KECCAK256_PROXY_CHILD_BYTECODE = keccak256(PROXY_CHILD_BYTECODE);
40		bytes32 internal constant KECCAK256_PROXY_CHILD_BYTECODE =
41	√	0x21c35dbe1b344a2488cf3321d6ce542f8e9f305544ff09e4993a62319a497c1f;
42
43		/**
44		@notice Returns the size of the code on a given address
45		@param _addr Address that may or may not contain code
46		@return size of the code on the given `_addr`
47		*/
48	√	function codeSize(address _addr) internal view returns (uint256 size) {
49		assembly {
50	√	size := extcodesize(_addr)
51		}
52		}
53
54		/**
55		@notice Creates a new contract with given `_creationCode` and `_salt`
56		@param _salt Salt of the contract creation, resulting address will be derivated from this value only
57		@param _creationCode Creation code (constructor) of the contract to be deployed, this value doesn't affect the resulting address
58		@return addr of the deployed contract, reverts on error
59		*/
60	√	function create3(bytes32 _salt, bytes memory _creationCode) internal returns (address addr) {
61	√	return create3(_salt, _creationCode, 0);
62		}
63
64		/**
65		@notice Creates a new contract with given `_creationCode` and `_salt`
66		@param _salt Salt of the contract creation, resulting address will be derivated from this value only
67		@param _creationCode Creation code (constructor) of the contract to be deployed, this value doesn't affect the resulting address
68		@param _value In WEI of ETH to be forwarded to child contract
69		@return addr of the deployed contract, reverts on error
70		*/
71		function create3(
72		bytes32 _salt,
73		bytes memory _creationCode,
74		uint256 _value
75	√	) internal returns (address addr) {
76		// Creation code
77	√	bytes memory creationCode = PROXY_CHILD_BYTECODE;
78
79		// Get target final address
80	√	addr = addressOf(_salt);
81	√	if (codeSize(addr) != 0) revert TargetAlreadyExists();
82
83		// Create CREATE2 proxy
84	√	address proxy;
85		assembly {
86	√	proxy := create2(0, add(creationCode, 32), mload(creationCode), _salt)
87		}
88	√	if (proxy == address(0)) revert ErrorCreatingProxy();
89
90		// Call proxy with final init code
91	√	(bool success, ) = proxy.call{value: _value}(_creationCode);
92	√	if (!success \|\| codeSize(addr) == 0) revert ErrorCreatingContract();
93		}
94
95		/**
96		@notice Computes the resulting address of a contract deployed using address(this) and the given `_salt`
97		@param _salt Salt of the contract creation, resulting address will be derivated from this value only
98		@return addr of the deployed contract, reverts on error
99
100		@dev The address creation formula is: keccak256(rlp([keccak256(0xff ++ address(this) ++ _salt ++ keccak256(childBytecode))[12:], 0x01]))
101		*/
102	√	function addressOf(bytes32 _salt) internal view returns (address) {
103	√	address proxy = address(
104		uint160(
105		uint256(
106		keccak256(
107		abi.encodePacked(
108		hex"ff",
109	√	address(this),
110	√	_salt,
111	√	KECCAK256_PROXY_CHILD_BYTECODE
112		)
113		)
114		)
115		)
116		);
117
118	√	return address(uint160(uint256(keccak256(abi.encodePacked(hex"d6_94", proxy, hex"01")))));
119		}
120		}
121

1		// SPDX-License-Identifier: MIT
2
3		pragma solidity 0.8.17;
4
5		import "../Interfaces/IERC3156FlashLender.sol";
6		import "../Interfaces/IWETH.sol";
7
8		abstract contract ERC3156FlashLender is IERC3156FlashLender {
9		// TODO: Fix / Finalize
10		uint256 public constant MAX_BPS = 10_000;
11		uint256 public constant MAX_FEE_BPS = 1_000; // 10%
12		bytes32 public constant FLASH_SUCCESS_VALUE = keccak256("ERC3156FlashBorrower.onFlashLoan");
13
14		// Functions to modify these variables must be included in impelemnting contracts if desired
15	√	uint16 public feeBps = 3; // may be subject to future adjustments through protocol governance
16		bool public flashLoansPaused;
17		}
18

1		// SPDX-License-Identifier: MIT
2		// OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol)
3		// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.
4
5		pragma solidity 0.8.17;
6
7		/**
8		* @dev Library for managing
9		* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
10		* types.
11		*
12		* Sets have the following properties:
13		*
14		* - Elements are added, removed, and checked for existence in constant time
15		* (O(1)).
16		* - Elements are enumerated in O(n). No guarantees are made on the ordering.
17		*
18		* ```solidity
19		* contract Example {
20		* // Add the library methods
21		* using EnumerableSet for EnumerableSet.AddressSet;
22		*
23		* // Declare a set state variable
24		* EnumerableSet.AddressSet private mySet;
25		* }
26		* ```
27		*
28		* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
29		* and `uint256` (`UintSet`) are supported.
30		*
31		* [WARNING]
32		* ====
33		* Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
34		* unusable.
35		* See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
36		*
37		* In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
38		* array of EnumerableSet.
39		* ====
40		*/
41		library EnumerableSet {
42		// To implement this library for multiple types with as little code
43		// repetition as possible, we write it in terms of a generic Set type with
44		// bytes32 values.
45		// The Set implementation uses private functions, and user-facing
46		// implementations (such as AddressSet) are just wrappers around the
47		// underlying Set.
48		// This means that we can only create new EnumerableSets for types that fit
49		// in bytes32.
50
51		struct Set {
52		// Storage of set values
53		bytes32[] _values;
54		// Position of the value in the `values` array, plus 1 because index 0
55		// means a value is not in the set.
56		mapping(bytes32 => uint256) _indexes;
57		}
58
59		/**
60		* @dev Add a value to a set. O(1).
61		*
62		* Returns true if the value was added to the set, that is if it was not
63		* already present.
64		*/
65	√	function _add(Set storage set, bytes32 value) private returns (bool) {
66	√	if (!_contains(set, value)) {
67	√	set._values.push(value);
68		// The value is stored at length-1, but we add 1 to all indexes
69		// and use 0 as a sentinel value
70	√	set._indexes[value] = set._values.length;
71	√	return true;
72		} else {
73		return false;
74		}
75		}
76
77		/**
78		* @dev Removes a value from a set. O(1).
79		*
80		* Returns true if the value was removed from the set, that is if it was
81		* present.
82		*/
83		function _remove(Set storage set, bytes32 value) private returns (bool) {
84		// We read and store the value's index to prevent multiple reads from the same storage slot
85		uint256 valueIndex = set._indexes[value];
86
87		if (valueIndex != 0) {
88		// Equivalent to contains(set, value)
89		// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
90		// the array, and then remove the last element (sometimes called as 'swap and pop').
91		// This modifies the order of the array, as noted in {at}.
92
93		uint256 toDeleteIndex = valueIndex - 1;
94		uint256 lastIndex = set._values.length - 1;
95
96		if (lastIndex != toDeleteIndex) {
97		bytes32 lastValue = set._values[lastIndex];
98
99		// Move the last value to the index where the value to delete is
100		set._values[toDeleteIndex] = lastValue;
101		// Update the index for the moved value
102		set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
103		}
104
105		// Delete the slot where the moved value was stored
106		set._values.pop();
107
108		// Delete the index for the deleted slot
109		delete set._indexes[value];
110
111		return true;
112		} else {
113		return false;
114		}
115		}
116
117		/**
118		* @dev Returns true if the value is in the set. O(1).
119		*/
120	√	function _contains(Set storage set, bytes32 value) private view returns (bool) {
121	√	return set._indexes[value] != 0;
122		}
123
124		/**
125		* @dev Returns the number of values on the set. O(1).
126		*/
127		function _length(Set storage set) private view returns (uint256) {
128		return set._values.length;
129		}
130
131		/**
132		* @dev Returns the value stored at position `index` in the set. O(1).
133		*
134		* Note that there are no guarantees on the ordering of values inside the
135		* array, and it may change when more values are added or removed.
136		*
137		* Requirements:
138		*
139		* - `index` must be strictly less than {length}.
140		*/
141		function _at(Set storage set, uint256 index) private view returns (bytes32) {
142		return set._values[index];
143		}
144
145		/**
146		* @dev Return the entire set in an array
147		*
148		* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
149		* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
150		* this function has an unbounded cost, and using it as part of a state-changing function may render the function
151		* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
152		*/
153		function _values(Set storage set) private view returns (bytes32[] memory) {
154		return set._values;
155		}
156
157		// Bytes32Set
158
159		struct Bytes32Set {
160		Set _inner;
161		}
162
163		/**
164		* @dev Add a value to a set. O(1).
165		*
166		* Returns true if the value was added to the set, that is if it was not
167		* already present.
168		*/
169	√	function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
170	√	return _add(set._inner, value);
171		}
172
173		/**
174		* @dev Removes a value from a set. O(1).
175		*
176		* Returns true if the value was removed from the set, that is if it was
177		* present.
178		*/
179		function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
180		return _remove(set._inner, value);
181		}
182
183		/**
184		* @dev Returns true if the value is in the set. O(1).
185		*/
186		function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
187		return _contains(set._inner, value);
188		}
189
190		/**
191		* @dev Returns the number of values in the set. O(1).
192		*/
193		function length(Bytes32Set storage set) internal view returns (uint256) {
194		return _length(set._inner);
195		}
196
197		/**
198		* @dev Returns the value stored at position `index` in the set. O(1).
199		*
200		* Note that there are no guarantees on the ordering of values inside the
201		* array, and it may change when more values are added or removed.
202		*
203		* Requirements:
204		*
205		* - `index` must be strictly less than {length}.
206		*/
207		function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
208		return _at(set._inner, index);
209		}
210
211		/**
212		* @dev Return the entire set in an array
213		*
214		* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
215		* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
216		* this function has an unbounded cost, and using it as part of a state-changing function may render the function
217		* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
218		*/
219		function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
220		bytes32[] memory store = _values(set._inner);
221		bytes32[] memory result;
222
223		/// @solidity memory-safe-assembly
224		assembly {
225		result := store
226		}
227
228		return result;
229		}
230
231		// AddressSet
232
233		struct AddressSet {
234		Set _inner;
235		}
236
237		/**
238		* @dev Add a value to a set. O(1).
239		*
240		* Returns true if the value was added to the set, that is if it was not
241		* already present.
242		*/
243	√	function add(AddressSet storage set, address value) internal returns (bool) {
244	√	return _add(set._inner, bytes32(uint256(uint160(value))));
245		}
246
247		/**
248		* @dev Removes a value from a set. O(1).
249		*
250		* Returns true if the value was removed from the set, that is if it was
251		* present.
252		*/
253		function remove(AddressSet storage set, address value) internal returns (bool) {
254		return _remove(set._inner, bytes32(uint256(uint160(value))));
255		}
256
257		/**
258		* @dev Returns true if the value is in the set. O(1).
259		*/
260	√	function contains(AddressSet storage set, address value) internal view returns (bool) {
261	√	return _contains(set._inner, bytes32(uint256(uint160(value))));
262		}
263
264		/**
265		* @dev Returns the number of values in the set. O(1).
266		*/
267		function length(AddressSet storage set) internal view returns (uint256) {
268		return _length(set._inner);
269		}
270
271		/**
272		* @dev Returns the value stored at position `index` in the set. O(1).
273		*
274		* Note that there are no guarantees on the ordering of values inside the
275		* array, and it may change when more values are added or removed.
276		*
277		* Requirements:
278		*
279		* - `index` must be strictly less than {length}.
280		*/
281		function at(AddressSet storage set, uint256 index) internal view returns (address) {
282		return address(uint160(uint256(_at(set._inner, index))));
283		}
284
285		/**
286		* @dev Return the entire set in an array
287		*
288		* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
289		* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
290		* this function has an unbounded cost, and using it as part of a state-changing function may render the function
291		* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
292		*/
293		function values(AddressSet storage set) internal view returns (address[] memory) {
294		bytes32[] memory store = _values(set._inner);
295		address[] memory result;
296
297		/// @solidity memory-safe-assembly
298		assembly {
299		result := store
300		}
301
302		return result;
303		}
304
305		// UintSet
306
307		struct UintSet {
308		Set _inner;
309		}
310
311		/**
312		* @dev Add a value to a set. O(1).
313		*
314		* Returns true if the value was added to the set, that is if it was not
315		* already present.
316		*/
317		function add(UintSet storage set, uint256 value) internal returns (bool) {
318		return _add(set._inner, bytes32(value));
319		}
320
321		/**
322		* @dev Removes a value from a set. O(1).
323		*
324		* Returns true if the value was removed from the set, that is if it was
325		* present.
326		*/
327		function remove(UintSet storage set, uint256 value) internal returns (bool) {
328		return _remove(set._inner, bytes32(value));
329		}
330
331		/**
332		* @dev Returns true if the value is in the set. O(1).
333		*/
334		function contains(UintSet storage set, uint256 value) internal view returns (bool) {
335		return _contains(set._inner, bytes32(value));
336		}
337
338		/**
339		* @dev Returns the number of values in the set. O(1).
340		*/
341		function length(UintSet storage set) internal view returns (uint256) {
342		return _length(set._inner);
343		}
344
345		/**
346		* @dev Returns the value stored at position `index` in the set. O(1).
347		*
348		* Note that there are no guarantees on the ordering of values inside the
349		* array, and it may change when more values are added or removed.
350		*
351		* Requirements:
352		*
353		* - `index` must be strictly less than {length}.
354		*/
355		function at(UintSet storage set, uint256 index) internal view returns (uint256) {
356		return uint256(_at(set._inner, index));
357		}
358
359		/**
360		* @dev Return the entire set in an array
361		*
362		* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
363		* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
364		* this function has an unbounded cost, and using it as part of a state-changing function may render the function
365		* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
366		*/
367		function values(UintSet storage set) internal view returns (uint256[] memory) {
368		bytes32[] memory store = _values(set._inner);
369		uint256[] memory result;
370
371		/// @solidity memory-safe-assembly
372		assembly {
373		result := store
374		}
375
376		return result;
377		}
378		}
379

1			// SPDX-License-Identifier: MIT
2			pragma solidity 0.8.17;
3
4			import "./IERC20.sol";
5
6			/**
7			* Based on the stETH:
8			* - https://docs.lido.fi/contracts/lido#
9			*/
10			interface ICollateralToken is IERC20 {
11			// Returns the amount of shares that corresponds to _ethAmount protocol-controlled Ether
12			function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);
13
14			// Returns the amount of Ether that corresponds to _sharesAmount token shares
15			function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);
16
17			// Moves `_sharesAmount` token shares from the caller's account to the `_recipient` account.
18			function transferShares(address _recipient, uint256 _sharesAmount) external returns (uint256);
19
20			// Returns the amount of shares owned by _account
21			function sharesOf(address _account) external view returns (uint256);
22
23			// Returns authorized oracle address
24			function getOracle() external view returns (address);
25			}
26

1			// SPDX-License-Identifier: MIT
2
3			pragma solidity 0.8.17;
4
5			/**
6			* Based on the OpenZeppelin IER20 interface:
7			* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol
8			*
9			* @dev Interface of the ERC20 standard as defined in the EIP.
10			*/
11			interface IERC20 {
12			/**
13			* @dev Returns the amount of tokens in existence.
14			*/
15			function totalSupply() external view returns (uint256);
16
17			/**
18			* @dev Returns the amount of tokens owned by `account`.
19			*/
20			function balanceOf(address account) external view returns (uint256);
21
22			/**
23			* @dev Moves `amount` tokens from the caller's account to `recipient`.
24			*
25			* Returns a boolean value indicating whether the operation succeeded.
26			*
27			* Emits a {Transfer} event.
28			*/
29			function transfer(address recipient, uint256 amount) external returns (bool);
30
31			/**
32			* @dev Returns the remaining number of tokens that `spender` will be
33			* allowed to spend on behalf of `owner` through {transferFrom}. This is
34			* zero by default.
35			*
36			* This value changes when {approve} or {transferFrom} are called.
37			*/
38			function allowance(address owner, address spender) external view returns (uint256);
39
40			function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
41
42			function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
43
44			/**
45			* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
46			*
47			* Returns a boolean value indicating whether the operation succeeded.
48			*
49			* IMPORTANT: Beware that changing an allowance with this method brings the risk
50			* that someone may use both the old and the new allowance by unfortunate
51			* transaction ordering. One possible solution to mitigate this race
52			* condition is to first reduce the spender's allowance to 0 and set the
53			* desired value afterwards:
54			* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
55			*
56			* Emits an {Approval} event.
57			*/
58			function approve(address spender, uint256 amount) external returns (bool);
59
60			/**
61			* @dev Moves `amount` tokens from `sender` to `recipient` using the
62			* allowance mechanism. `amount` is then deducted from the caller's
63			* allowance.
64			*
65			* Returns a boolean value indicating whether the operation succeeded.
66			*
67			* Emits a {Transfer} event.
68			*/
69			function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
70
71			function name() external view returns (string memory);
72
73			function symbol() external view returns (string memory);
74
75			function decimals() external view returns (uint8);
76
77			/**
78			* @dev Emitted when `value` tokens are moved from one account (`from`) to
79			* another (`to`).
80			*
81			* Note that `value` may be zero.
82			*/
83			event Transfer(address indexed from, address indexed to, uint256 value);
84
85			/**
86			* @dev Emitted when the allowance of a `spender` for an `owner` is set by
87			* a call to {approve}. `value` is the new allowance.
88			*/
89			event Approval(address indexed owner, address indexed spender, uint256 value);
90			}
91

1			// SPDX-License-Identifier: MIT
2
3			pragma solidity 0.8.17;
4
5			/**
6			* @dev Interface of the ERC2612 standard as defined in the EIP.
7			*
8			* Adds the {permit} method, which can be used to change one's
9			* {IERC20-allowance} without having to send a transaction, by signing a
10			* message. This allows users to spend tokens without having to hold Ether.
11			*
12			* See https://eips.ethereum.org/EIPS/eip-2612.
13			*
14			* Code adapted from https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2237/
15			*/
16			interface IERC2612 {
17			/**
18			* @dev Sets `amount` as the allowance of `spender` over `owner`'s tokens,
19			* given `owner`'s signed approval.
20			*
21			* IMPORTANT: The same issues {IERC20-approve} has related to transaction
22			* ordering also apply here.
23			*
24			* Emits an {Approval} event.
25			*
26			* Requirements:
27			*
28			* - `owner` cannot be the zero address.
29			* - `spender` cannot be the zero address.
30			* - `deadline` must be a timestamp in the future.
31			* - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
32			* over the EIP712-formatted function arguments.
33			* - the signature must use ``owner``'s current nonce (see {nonces}).
34			*
35			* For more information on the signature format, see the
36			* https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
37			* section].
38			*/
39			function permit(
40			address owner,
41			address spender,
42			uint256 amount,
43			uint256 deadline,
44			uint8 v,
45			bytes32 r,
46			bytes32 s
47			) external;
48
49			/**
50			* @dev Returns the current ERC2612 nonce for `owner`. This value must be
51			* included whenever a signature is generated for {permit}.
52			*
53			* Every successful call to {permit} increases `owner`'s nonce by one. This
54			* prevents a signature from being used multiple times.
55			*
56			* `owner` can limit the time a Permit is valid for by setting `deadline` to
57			* a value in the near future. The deadline argument can be set to uint256(-1) to
58			* create Permits that effectively never expire.
59			*/
60			function nonces(address owner) external view returns (uint256);
61
62			function version() external view returns (string memory);
63
64			function permitTypeHash() external view returns (bytes32);
65
66			function domainSeparator() external view returns (bytes32);
67			}
68

1			// SPDX-License-Identifier: AGPL-3.0-only
2			pragma solidity 0.8.17;
3
4			import "./EnumerableSet.sol";
5
6			/// @notice Role based Authority that supports up to 256 roles.
7			/// @author BadgerDAO
8			/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/authorities/RolesAuthority.sol)
9			/// @author Modified from Dappsys (https://github.com/dapphub/ds-roles/blob/master/src/roles.sol)
10			interface IRolesAuthority {
11			event UserRoleUpdated(address indexed user, uint8 indexed role, bool enabled);
12
13			event PublicCapabilityUpdated(address indexed target, bytes4 indexed functionSig, bool enabled);
14			event CapabilityBurned(address indexed target, bytes4 indexed functionSig);
15
16			event RoleCapabilityUpdated(
17			uint8 indexed role,
18			address indexed target,
19			bytes4 indexed functionSig,
20			bool enabled
21			);
22
23			enum CapabilityFlag {
24			None,
25			Public,
26			Burned
27			}
28			}
29

1			// SPDX-License-Identifier: MIT
2
3			pragma solidity 0.8.17;
4
5			import "./BaseMath.sol";
6			import "./LiquityMath.sol";
7			import "../Interfaces/IActivePool.sol";
8			import "../Interfaces/IPriceFeed.sol";
9			import "../Interfaces/ILiquityBase.sol";
10			import "../Dependencies/ICollateralToken.sol";
11
12			/*
13			* Base contract for CdpManager, BorrowerOperations. Contains global system constants and
14			* common functions.
15			*/
16			contract LiquityBase is BaseMath, ILiquityBase {
17			// Collateral Ratio applied for Liquidation Incentive
18			// i.e., liquidator repay $1 worth of debt to get back $1.03 worth of collateral
19	√	⟳	uint256 public constant LICR = 1030000000000000000; // 103%
20
21			// Minimum collateral ratio for individual cdps
22	√	⟳	uint256 public constant MCR = 1100000000000000000; // 110%
23
24			// Critical system collateral ratio. If the system's total collateral ratio (TCR) falls below the CCR, Recovery Mode is triggered.
25	√	⟳	uint256 public constant CCR = 1250000000000000000; // 125%
26
27			// Amount of stETH collateral to be locked in active pool on opening cdps
28	√	⟳	uint256 public constant LIQUIDATOR_REWARD = 2e17;
29
30			// Minimum amount of stETH collateral a CDP must have
31	√	⟳	uint256 public constant MIN_NET_COLL = 2e18;
32
33			uint256 public constant PERCENT_DIVISOR = 200; // dividing by 200 yields 0.5%
34
35			uint256 public constant BORROWING_FEE_FLOOR = 0; // 0.5%
36
37	√		uint256 public constant STAKING_REWARD_SPLIT = 5_000; // taking 50% cut from staking reward
38
39	√	⟳	uint256 public constant MAX_REWARD_SPLIT = 10_000;
40
41			IActivePool public immutable activePool;
42
43			IPriceFeed public immutable override priceFeed;
44
45			// the only collateral token allowed in CDP
46			ICollateralToken public immutable collateral;
47
48			constructor(address _activePoolAddress, address _priceFeedAddress, address _collateralAddress) {
49	√		activePool = IActivePool(_activePoolAddress);
50	√		priceFeed = IPriceFeed(_priceFeedAddress);
51	√		collateral = ICollateralToken(_collateralAddress);
52			}
53
54			// --- Gas compensation functions ---
55
56	√	⟳	function _getNetColl(uint256 _coll) internal pure returns (uint256) {
57	√	⟳	return _coll - LIQUIDATOR_REWARD;
58			}
59
60			/**
61			@notice Get the entire system collateral
62			@notice Entire system collateral = collateral stored in ActivePool, using their internal accounting
63			@dev Coll stored for liquidator rewards or coll in CollSurplusPool are not included
64			*/
65	√	⟳	function getSystemCollShares() public view returns (uint256 entireSystemColl) {
66	√	⟳	return (activePool.getSystemCollShares());
67			}
68
69			/**
70			@notice Get the entire system debt
71			@notice Entire system collateral = collateral stored in ActivePool, using their internal accounting
72			*/
73	√	⟳	function _getSystemDebt() internal view returns (uint256 entireSystemDebt) {
74	√	⟳	return (activePool.getSystemDebt());
75			}
76
77	√	⟳	function _getTCR(uint256 _price) internal view returns (uint256 TCR) {
78	√	⟳	(TCR, , ) = _getTCRWithSystemDebtAndCollShares(_price);
79			}
80
81			function _getTCRWithSystemDebtAndCollShares(
82			uint256 _price
83	√	⟳	) internal view returns (uint256 TCR, uint256 _coll, uint256 _debt) {
84	√	⟳	uint256 entireSystemColl = getSystemCollShares();
85	√	⟳	uint256 entireSystemDebt = _getSystemDebt();
86
87	√	⟳	uint256 _underlyingCollateral = collateral.getPooledEthByShares(entireSystemColl);
88	√	⟳	TCR = LiquityMath._computeCR(_underlyingCollateral, entireSystemDebt, _price);
89
90	√	⟳	return (TCR, entireSystemColl, entireSystemDebt);
91			}
92
93	√	⟳	function _checkRecoveryMode(uint256 _price) internal view returns (bool) {
94	√	⟳	return _checkRecoveryModeForTCR(_getTCR(_price));
95			}
96
97	√	⟳	function _checkRecoveryModeForTCR(uint256 _tcr) internal view returns (bool) {
98	√	⟳	return _tcr < CCR;
99			}
100
101			function _requireUserAcceptsFee(
102			uint256 _fee,
103			uint256 _amount,
104			uint256 _maxFeePercentage
105			) internal pure {
106	√	⟳	uint256 feePercentage = (_fee * DECIMAL_PRECISION) / _amount;
107	√	⟳	require(feePercentage <= _maxFeePercentage, "Fee exceeded provided maximum");
108			}
109
110			// Convert debt denominated in ETH to debt denominated in BTC given that _price is ETH/BTC
111			// _debt is denominated in ETH
112			// _price is ETH/BTC
113			function _convertDebtDenominationToBtc(
114			uint256 _debt,
115			uint256 _price
116	√	⟳	) internal pure returns (uint256) {
117	√	⟳	return (_debt * _price) / DECIMAL_PRECISION;
118			}
119			}
120

1			// SPDX-License-Identifier: MIT
2
3			pragma solidity 0.8.17;
4
5			library LiquityMath {
6	√	⟳	uint256 internal constant DECIMAL_PRECISION = 1e18;
7	√	⟳	uint256 public constant MAX_TCR = type(uint256).max;
8
9			/* Precision for Nominal ICR (independent of price). Rationale for the value:
10			*
11			* - Making it “too high” could lead to overflows.
12			* - Making it “too low” could lead to an ICR equal to zero, due to truncation from Solidity floor division.
13			*
14			* This value of 1e20 is chosen for safety: the NICR will only overflow for numerator > ~1e39 ETH,
15			* and will only truncate to 0 if the denominator is at least 1e20 times greater than the numerator.
16			*
17			*/
18	√	⟳	uint256 internal constant NICR_PRECISION = 1e20;
19
20	√	⟳	function _min(uint256 _a, uint256 _b) internal pure returns (uint256) {
21	√	⟳	return (_a < _b) ? _a : _b;
22			}
23
24			function _max(uint256 _a, uint256 _b) internal pure returns (uint256) {
25			return (_a >= _b) ? _a : _b;
26			}
27
28			/*
29			* Multiply two decimal numbers and use normal rounding rules:
30			* -round product up if 19'th mantissa digit >= 5
31			* -round product down if 19'th mantissa digit < 5
32			*
33			* Used only inside the exponentiation, _decPow().
34			*/
35	√	⟳	function decMul(uint256 x, uint256 y) internal pure returns (uint256 decProd) {
36	√	⟳	uint256 prod_xy = x * y;
37
38	√	⟳	decProd = (prod_xy + (DECIMAL_PRECISION / 2)) / DECIMAL_PRECISION;
39			}
40
41			/*
42			* _decPow: Exponentiation function for 18-digit decimal base, and integer exponent n.
43			*
44			* Uses the efficient "exponentiation by squaring" algorithm. O(log(n)) complexity.
45			*
46			* Called by two functions that represent time in units of minutes:
47			* 1) CdpManager._calcDecayedBaseRate
48			* 2) CommunityIssuance._getCumulativeIssuanceFraction
49			*
50			* The exponent is capped to avoid reverting due to overflow. The cap 525600000 equals
51			* "minutes in 1000 years": 60 * 24 * 365 * 1000
52			*
53			* If a period of > 1000 years is ever used as an exponent in either of the above functions, the result will be
54			* negligibly different from just passing the cap, since:
55			*
56			* In function 1), the decayed base rate will be 0 for 1000 years or > 1000 years
57			* In function 2), the difference in tokens issued at 1000 years and any time > 1000 years, will be negligible
58			*/
59	√	⟳	function _decPow(uint256 _base, uint256 _minutes) internal pure returns (uint256) {
60	√	⟳	if (_minutes > 525600000) {
61			_minutes = 525600000;
62			} // cap to avoid overflow
63
64	√	⟳	if (_minutes == 0) {
65	√		return DECIMAL_PRECISION;
66			}
67
68	√	⟳	uint256 y = DECIMAL_PRECISION;
69	√	⟳	uint256 x = _base;
70	√	⟳	uint256 n = _minutes;
71
72			// Exponentiation-by-squaring
73	√	⟳	while (n > 1) {
74	√	⟳	if (n % 2 == 0) {
75	√	⟳	x = decMul(x, x);
76	√	⟳	n = n / 2;
77			} else {
78			// if (n % 2 != 0)
79	√	⟳	y = decMul(x, y);
80	√	⟳	x = decMul(x, x);
81	√	⟳	n = (n - 1) / 2;
82			}
83			}
84
85	√	⟳	return decMul(x, y);
86			}
87
88			function _getAbsoluteDifference(uint256 _a, uint256 _b) internal pure returns (uint256) {
89			return (_a >= _b) ? (_a - _b) : (_b - _a);
90			}
91
92	√	⟳	function _computeNominalCR(uint256 _coll, uint256 _debt) internal pure returns (uint256) {
93	√	⟳	if (_debt > 0) {
94	√	⟳	return (_coll * NICR_PRECISION) / _debt;
95			}
96			// Return the maximal value for uint256 if the Cdp has a debt of 0. Represents "infinite" CR.
97			else {
98			// if (_debt == 0)
99	√	⟳	return MAX_TCR;
100			}
101			}
102
103			function _computeCR(
104			uint256 _coll,
105			uint256 _debt,
106			uint256 _price
107	√	⟳	) internal pure returns (uint256) {
108	√	⟳	if (_debt > 0) {
109	√	⟳	uint256 newCollRatio = (_coll * _price) / _debt;
110
111	√	⟳	return newCollRatio;
112			}
113			// Return the maximal value for uint256 if the Cdp has a debt of 0. Represents "infinite" CR.
114			else {
115			// if (_debt == 0)
116	√	⟳	return MAX_TCR;
117			}
118			}
119			}
120

1			// SPDX-License-Identifier: MIT
2
3			pragma solidity 0.8.17;
4			import "../Interfaces/IPermitNonce.sol";
5
6			/**
7			* @dev This abstract contract provides a mapping from address to nonce (uint256) used for permit signature
8			*/
9			contract PermitNonce is IPermitNonce {
10			mapping(address => uint256) internal _nonces;
11
12			/// @dev Increase current nonce for msg.sender by one.
13			/// @notice This function could be used to invalidate any signed permit out there
14			function increasePermitNonce() external returns (uint256) {
15			return ++_nonces[msg.sender];
16			}
17
18			/// @dev Return current nonce for msg.sender fOR EIP-2612 compatibility
19			function nonces(address owner) external view virtual returns (uint256) {
20			return _nonces[owner];
21			}
22			}
23

1			// SPDX-License-Identifier: AGPL-3.0-only
2			pragma solidity 0.8.17;
3
4			/// @notice Gas optimized reentrancy protection for smart contracts.
5			/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/ReentrancyGuard.sol)
6			/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol)
7			abstract contract ReentrancyGuard {
8	√	⟳	uint256 internal constant OPEN = 1;
9	√	⟳	uint256 internal constant LOCKED = 2;
10
11	√	⟳	uint256 public locked = OPEN;
12
13			modifier nonReentrant() virtual {
14			require(locked == OPEN, "ReentrancyGuard: Reentrancy in nonReentrant call");
15
16			locked = LOCKED;
17
18			_;
19
20			locked = OPEN;
21			}
22			}
23

1			// SPDX-License-Identifier: AGPL-3.0-only
2			pragma solidity 0.8.17;
3
4			import {IRolesAuthority} from "./IRolesAuthority.sol";
5			import {Auth, Authority} from "./Auth.sol";
6			import "./EnumerableSet.sol";
7
8			/// @notice Role based Authority that supports up to 256 roles.
9			/// @author BadgerDAO
10			/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/authorities/RolesAuthority.sol)
11			/// @author Modified from Dappsys (https://github.com/dapphub/ds-roles/blob/master/src/roles.sol)
12			contract RolesAuthority is IRolesAuthority, Auth, Authority {
13			using EnumerableSet for EnumerableSet.Bytes32Set;
14			using EnumerableSet for EnumerableSet.AddressSet;
15
16			/*//////////////////////////////////////////////////////////////
17			CONSTRUCTOR
18			//////////////////////////////////////////////////////////////*/
19
20	√		constructor(address _owner, Authority _authority) Auth(_owner, _authority) {}
21
22			/*//////////////////////////////////////////////////////////////
23			ROLE/USER STORAGE
24			//////////////////////////////////////////////////////////////*/
25
26			EnumerableSet.AddressSet internal users;
27			EnumerableSet.AddressSet internal targets;
28			mapping(address => EnumerableSet.Bytes32Set) internal enabledFunctionSigsByTarget;
29
30			EnumerableSet.Bytes32Set internal enabledFunctionSigsPublic;
31
32			mapping(address => bytes32) public getUserRoles;
33
34			mapping(address => mapping(bytes4 => CapabilityFlag)) public capabilityFlag;
35
36			mapping(address => mapping(bytes4 => bytes32)) public getRolesWithCapability;
37
38			function doesUserHaveRole(address user, uint8 role) public view virtual returns (bool) {
39			return (uint256(getUserRoles[user]) >> role) & 1 != 0;
40			}
41
42			function doesRoleHaveCapability(
43			uint8 role,
44			address target,
45			bytes4 functionSig
46			) public view virtual returns (bool) {
47			return (uint256(getRolesWithCapability[target][functionSig]) >> role) & 1 != 0;
48			}
49
50			function isPublicCapability(address target, bytes4 functionSig) public view returns (bool) {
51			return capabilityFlag[target][functionSig] == CapabilityFlag.Public;
52			}
53
54			/*//////////////////////////////////////////////////////////////
55			AUTHORIZATION LOGIC
56			//////////////////////////////////////////////////////////////*/
57
58			/**
59			@notice A user can call a given function signature on a given target address if:
60			- The capability has not been burned
61			- That capability is public, or the user has a role that has been granted the capability to call the function
62			*/
63			function canCall(
64			address user,
65			address target,
66			bytes4 functionSig
67	√	⟳	) public view virtual override returns (bool) {
68	√	⟳	CapabilityFlag flag = capabilityFlag[target][functionSig];
69
70	√	⟳	if (flag == CapabilityFlag.Burned) {
71			return false;
72	√	⟳	} else if (flag == CapabilityFlag.Public) {
73			return true;
74			} else {
75	√	⟳	return bytes32(0) != getUserRoles[user] & getRolesWithCapability[target][functionSig];
76			}
77			}
78
79			/*//////////////////////////////////////////////////////////////
80			ROLE CAPABILITY CONFIGURATION LOGIC
81			//////////////////////////////////////////////////////////////*/
82
83			/// @notice Set a capability flag as public, meaning any account can call it. Or revoke this capability.
84			/// @dev A capability cannot be made public if it has been burned.
85			function setPublicCapability(
86			address target,
87			bytes4 functionSig,
88			bool enabled
89			) public virtual requiresAuth {
90			require(
91			capabilityFlag[target][functionSig] != CapabilityFlag.Burned,
92			"RolesAuthority: Capability Burned"
93			);
94
95			if (enabled) {
96			capabilityFlag[target][functionSig] = CapabilityFlag.Public;
97			} else {
98			capabilityFlag[target][functionSig] = CapabilityFlag.None;
99			}
100
101			emit PublicCapabilityUpdated(target, functionSig, enabled);
102			}
103
104			/// @notice Grant a specified role the ability to call a function on a target.
105			/// @notice Has no effect
106			function setRoleCapability(
107			uint8 role,
108			address target,
109			bytes4 functionSig,
110			bool enabled
111			) public virtual requiresAuth {
112	√		if (enabled) {
113	√		getRolesWithCapability[target][functionSig] \|= bytes32(1 << role);
114	√		enabledFunctionSigsByTarget[target].add(bytes32(functionSig));
115
116	√		if (!targets.contains(target)) {
117	√		targets.add(target);
118			}
119			} else {
120			getRolesWithCapability[target][functionSig] &= ~bytes32(1 << role);
121			enabledFunctionSigsByTarget[target].remove(bytes32(functionSig));
122
123			// If no enabled function signatures exist for this target, remove target
124			if (enabledFunctionSigsByTarget[target].length() == 0) {
125			targets.remove(target);
126			}
127			}
128
129	√		emit RoleCapabilityUpdated(role, target, functionSig, enabled);
130			}
131
132			/// @notice Permanently burns a capability for a target.
133			function burnCapability(address target, bytes4 functionSig) public virtual requiresAuth {
134			require(
135			capabilityFlag[target][functionSig] != CapabilityFlag.Burned,
136			"RolesAuthority: Capability Burned"
137			);
138			capabilityFlag[target][functionSig] = CapabilityFlag.Burned;
139
140			emit CapabilityBurned(target, functionSig);
141			}
142
143			/*//////////////////////////////////////////////////////////////
144			USER ROLE ASSIGNMENT LOGIC
145			//////////////////////////////////////////////////////////////*/
146
147			function setUserRole(address user, uint8 role, bool enabled) public virtual requiresAuth {
148	√		if (enabled) {
149	√		getUserRoles[user] \|= bytes32(1 << role);
150
151	√		if (!users.contains(user)) {
152	√		users.add(user);
153			}
154			} else {
155			getUserRoles[user] &= ~bytes32(1 << role);
156
157			// Remove user if no more roles
158			if (getUserRoles[user] == bytes32(0)) {
159			users.remove(user);
160			}
161			}
162
163	√		emit UserRoleUpdated(user, role, enabled);
164			}
165			}
166

1			// SPDX-License-Identifier: MIT
2
3			pragma solidity 0.8.17;
4
5			/**
6			* Based on OpenZeppelin's SafeMath:
7			* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/SafeMath.sol
8			*
9			* @dev Wrappers over Solidity's arithmetic operations with added overflow
10			* checks.
11			*
12			* Arithmetic operations in Solidity wrap on overflow. This can easily result
13			* in bugs, because programmers usually assume that an overflow raises an
14			* error, which is the standard behavior in high level programming languages.
15			* `SafeMath` restores this intuition by reverting the transaction when an
16			* operation overflows.
17			*
18			* Using this library instead of the unchecked operations eliminates an entire
19			* class of bugs, so it's recommended to use it always.
20			*/
21			library SafeMath {
22			/**
23			* @dev Returns the addition of two unsigned integers, reverting on
24			* overflow.
25			*
26			* Counterpart to Solidity's `+` operator.
27			*
28			* Requirements:
29			* - Addition cannot overflow.
30			*/
31			function add(uint256 a, uint256 b) internal pure returns (uint256) {
32			uint256 c = a + b;
33			require(c >= a, "SafeMath: addition overflow");
34
35			return c;
36			}
37
38			/**
39			* @dev Returns the subtraction of two unsigned integers, reverting on
40			* overflow (when the result is negative).
41			*
42			* Counterpart to Solidity's `-` operator.
43			*
44			* Requirements:
45			* - Subtraction cannot overflow.
46			*/
47			function sub(uint256 a, uint256 b) internal pure returns (uint256) {
48			return sub(a, b, "SafeMath: subtraction overflow");
49			}
50
51			/**
52			* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
53			* overflow (when the result is negative).
54			*
55			* Counterpart to Solidity's `-` operator.
56			*
57			* Requirements:
58			* - Subtraction cannot overflow.
59			*
60			* _Available since v2.4.0._
61			*/
62			function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
63			require(b <= a, errorMessage);
64			uint256 c = a - b;
65
66			return c;
67			}
68
69			/**
70			* @dev Returns the multiplication of two unsigned integers, reverting on
71			* overflow.
72			*
73			* Counterpart to Solidity's `*` operator.
74			*
75			* Requirements:
76			* - Multiplication cannot overflow.
77			*/
78			function mul(uint256 a, uint256 b) internal pure returns (uint256) {
79			// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
80			// benefit is lost if 'b' is also tested.
81			// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
82			if (a == 0) {
83			return 0;
84			}
85
86			uint256 c = a * b;
87			require(c / a == b, "SafeMath: multiplication overflow");
88
89			return c;
90			}
91
92			/**
93			* @dev Returns the integer division of two unsigned integers. Reverts on
94			* division by zero. The result is rounded towards zero.
95			*
96			* Counterpart to Solidity's `/` operator. Note: this function uses a
97			* `revert` opcode (which leaves remaining gas untouched) while Solidity
98			* uses an invalid opcode to revert (consuming all remaining gas).
99			*
100			* Requirements:
101			* - The divisor cannot be zero.
102			*/
103			function div(uint256 a, uint256 b) internal pure returns (uint256) {
104			return div(a, b, "SafeMath: division by zero");
105			}
106
107			/**
108			* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
109			* division by zero. The result is rounded towards zero.
110			*
111			* Counterpart to Solidity's `/` operator. Note: this function uses a
112			* `revert` opcode (which leaves remaining gas untouched) while Solidity
113			* uses an invalid opcode to revert (consuming all remaining gas).
114			*
115			* Requirements:
116			* - The divisor cannot be zero.
117			*
118			* _Available since v2.4.0._
119			*/
120			function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
121			// Solidity only automatically asserts when dividing by 0
122			require(b > 0, errorMessage);
123			uint256 c = a / b;
124			// assert(a == b * c + a % b); // There is no case in which this doesn't hold
125
126			return c;
127			}
128
129			/**
130			* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
131			* Reverts when dividing by zero.
132			*
133			* Counterpart to Solidity's `%` operator. This function uses a `revert`
134			* opcode (which leaves remaining gas untouched) while Solidity uses an
135			* invalid opcode to revert (consuming all remaining gas).
136			*
137			* Requirements:
138			* - The divisor cannot be zero.
139			*/
140			function mod(uint256 a, uint256 b) internal pure returns (uint256) {
141			return mod(a, b, "SafeMath: modulo by zero");
142			}
143
144			/**
145			* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
146			* Reverts with custom message when dividing by zero.
147			*
148			* Counterpart to Solidity's `%` operator. This function uses a `revert`
149			* opcode (which leaves remaining gas untouched) while Solidity uses an
150			* invalid opcode to revert (consuming all remaining gas).
151			*
152			* Requirements:
153			* - The divisor cannot be zero.
154			*
155			* _Available since v2.4.0._
156			*/
157			function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
158			require(b != 0, errorMessage);
159			return a % b;
160			}
161			}
162

1		// SPDX-License-Identifier: MIT
2
3		pragma solidity 0.8.17;
4
5		import "./Dependencies/Create3.sol";
6		import "./Dependencies/Ownable.sol";
7
8	√	contract EBTCDeployer is Ownable {
9		string public constant name = "eBTC Deployer";
10
11	√	string public constant AUTHORITY = "ebtc.v1.authority";
12	√	string public constant LIQUIDATION_LIBRARY = "ebtc.v1.liquidationLibrary";
13	√	string public constant CDP_MANAGER = "ebtc.v1.cdpManager";
14	√	string public constant BORROWER_OPERATIONS = "ebtc.v1.borrowerOperations";
15
16	√	string public constant PRICE_FEED = "ebtc.v1.priceFeed";
17	√	string public constant SORTED_CDPS = "ebtc.v1.sortedCdps";
18
19	√	string public constant ACTIVE_POOL = "ebtc.v1.activePool";
20	√	string public constant COLL_SURPLUS_POOL = "ebtc.v1.collSurplusPool";
21
22	√	string public constant HINT_HELPERS = "ebtc.v1.hintHelpers";
23	√	string public constant EBTC_TOKEN = "ebtc.v1.eBTCToken";
24	√	string public constant FEE_RECIPIENT = "ebtc.v1.feeRecipient";
25		string public constant MULTI_CDP_GETTER = "ebtc.v1.multiCdpGetter";
26
27		event ContractDeployed(address indexed contractAddress, string contractName, bytes32 salt);
28
29		struct EbtcAddresses {
30		address authorityAddress;
31		address liquidationLibraryAddress;
32		address cdpManagerAddress;
33		address borrowerOperationsAddress;
34		address priceFeedAddress;
35		address sortedCdpsAddress;
36		address activePoolAddress;
37		address collSurplusPoolAddress;
38		address hintHelpersAddress;
39		address ebtcTokenAddress;
40		address feeRecipientAddress;
41		address multiCdpGetterAddress;
42		}
43
44		/**
45		@notice Helper method to return a set of future addresses for eBTC. Intended to be used in the order specified.
46
47		@dev The order is as follows:
48		0: authority
49		1: liquidationLibrary
50		2: cdpManager
51		3: borrowerOperations
52		4: priceFeed
53		5; sortedCdps
54		6: activePool
55		7: collSurplusPool
56		8: hintHelpers
57		9: eBTCToken
58		10: feeRecipient
59		11: multiCdpGetter
60
61
62		*/
63	√	function getFutureEbtcAddresses() public view returns (EbtcAddresses memory) {
64	√	EbtcAddresses memory addresses = EbtcAddresses(
65	√	Create3.addressOf(keccak256(abi.encodePacked(AUTHORITY))),
66	√	Create3.addressOf(keccak256(abi.encodePacked(LIQUIDATION_LIBRARY))),
67	√	Create3.addressOf(keccak256(abi.encodePacked(CDP_MANAGER))),
68	√	Create3.addressOf(keccak256(abi.encodePacked(BORROWER_OPERATIONS))),
69	√	Create3.addressOf(keccak256(abi.encodePacked(PRICE_FEED))),
70	√	Create3.addressOf(keccak256(abi.encodePacked(SORTED_CDPS))),
71	√	Create3.addressOf(keccak256(abi.encodePacked(ACTIVE_POOL))),
72	√	Create3.addressOf(keccak256(abi.encodePacked(COLL_SURPLUS_POOL))),
73	√	Create3.addressOf(keccak256(abi.encodePacked(HINT_HELPERS))),
74	√	Create3.addressOf(keccak256(abi.encodePacked(EBTC_TOKEN))),
75	√	Create3.addressOf(keccak256(abi.encodePacked(FEE_RECIPIENT))),
76	√	Create3.addressOf(keccak256(abi.encodePacked(MULTI_CDP_GETTER)))
77		);
78
79	√	return addresses;
80		}
81
82		/**
83		@notice Deploy a contract using salt in string format and arbitrary runtime code.
84		@dev Intended use is: get the future eBTC addresses, then deploy the appropriate contract to each address via this method, building the constructor using the mapped addresses
85		@dev no enforcment of bytecode at address as we can't know the runtime code in this contract due to space constraints
86		@dev gated to given deployer EOA to ensure no interference with process, given proper actions by deployer
87		*/
88		function deploy(
89		string memory _saltString,
90		bytes memory _creationCode
91	√	) public returns (address deployedAddress) {
92	√	bytes32 _salt = keccak256(abi.encodePacked(_saltString));
93	√	deployedAddress = Create3.create3(_salt, _creationCode);
94	√	emit ContractDeployed(deployedAddress, _saltString, _salt);
95		}
96
97		function deployWithCreationCodeAndConstructorArgs(
98		string memory _saltString,
99		bytes memory creationCode,
100		bytes memory constructionArgs
101		) external returns (address) {
102		bytes memory _data = abi.encodePacked(creationCode, constructionArgs);
103		return deploy(_saltString, _data);
104		}
105
106		function deployWithCreationCode(
107		string memory _saltString,
108		bytes memory creationCode
109		) external returns (address) {
110		return deploy(_saltString, creationCode);
111		}
112
113		function addressOf(string memory _saltString) external view returns (address) {
114		bytes32 _salt = keccak256(abi.encodePacked(_saltString));
115		return Create3.addressOf(_salt);
116		}
117
118		function addressOfSalt(bytes32 _salt) external view returns (address) {
119		return Create3.addressOf(_salt);
120		}
121
122		/**
123		@notice Create the creation code for a contract with the given runtime code.
124		@dev credit: https://github.com/0xsequence/create3/blob/master/contracts/test_utils/Create3Imp.sol
125		*/
126		function creationCodeFor(bytes memory _code) internal pure returns (bytes memory) {
127		/*
128		0x00 0x63 0x63XXXXXX PUSH4 _code.length size
129		0x01 0x80 0x80 DUP1 size size
130		0x02 0x60 0x600e PUSH1 14 14 size size
131		0x03 0x60 0x6000 PUSH1 00 0 14 size size
132		0x04 0x39 0x39 CODECOPY size
133		0x05 0x60 0x6000 PUSH1 00 0 size
134		0x06 0xf3 0xf3 RETURN
135		<CODE>
136		*/
137
138		return
139		abi.encodePacked(hex"63", uint32(_code.length), hex"80_60_0E_60_00_39_60_00_F3", _code);
140		}
141		}
142

1			// SPDX-License-Identifier: MIT
2
3			pragma solidity 0.8.17;
4
5			import "./Interfaces/IEBTCToken.sol";
6
7			import "./Dependencies/AuthNoOwner.sol";
8			import "./Dependencies/PermitNonce.sol";
9
10			/*
11			*
12			* Based upon OpenZeppelin's ERC20 contract:
13			* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol
14			*
15			* and their EIP2612 (ERC20Permit / ERC712) functionality:
16			* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/53516bc555a454862470e7860a9b5254db4d00f5/contracts/token/ERC20/ERC20Permit.sol
17			*
18			*
19			* --- Functionality added specific to the EBTCToken ---
20			*
21			* 1) Transfer protection: blacklist of addresses that are invalid recipients (i.e. core Liquity contracts) in external
22			* transfer() and transferFrom() calls. The purpose is to protect users from losing tokens by mistakenly sending EBTC directly to a Liquity
23			* core contract, when they should rather call the right function.
24			*/
25
26			contract EBTCToken is IEBTCToken, AuthNoOwner, PermitNonce {
27			uint256 private _totalSupply;
28			string internal constant _NAME = "EBTC Stablecoin";
29			string internal constant _SYMBOL = "EBTC";
30			string internal constant _VERSION = "1";
31			uint8 internal constant _DECIMALS = 18;
32
33			// --- Data for EIP2612 ---
34
35			// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
36			bytes32 private constant _PERMIT_TYPEHASH =
37			0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
38			// keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
39			bytes32 private constant _TYPE_HASH =
40	√		0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;
41
42			// Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
43			// invalidate the cached domain separator if the chain id changes.
44			bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
45			uint256 private immutable _CACHED_CHAIN_ID;
46
47			bytes32 private immutable _HASHED_NAME;
48			bytes32 private immutable _HASHED_VERSION;
49
50			// User data for EBTC token
51			mapping(address => uint256) private _balances;
52			mapping(address => mapping(address => uint256)) private _allowances;
53
54			// --- Addresses ---
55			address public immutable cdpManagerAddress;
56			address public immutable borrowerOperationsAddress;
57
58			constructor(
59			address _cdpManagerAddress,
60			address _borrowerOperationsAddress,
61			address _authorityAddress
62			) {
63	√		_initializeAuthority(_authorityAddress);
64
65	√		cdpManagerAddress = _cdpManagerAddress;
66	√		borrowerOperationsAddress = _borrowerOperationsAddress;
67
68	√		bytes32 hashedName = keccak256(bytes(_NAME));
69	√		bytes32 hashedVersion = keccak256(bytes(_VERSION));
70
71	√		_HASHED_NAME = hashedName;
72	√		_HASHED_VERSION = hashedVersion;
73	√		_CACHED_CHAIN_ID = _chainID();
74	√		_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(_TYPE_HASH, hashedName, hashedVersion);
75			}
76
77			// --- Functions for intra-Liquity calls ---
78
79			/**
80			* @notice Mint new tokens
81			* @dev Internal system function - only callable by BorrowerOperations or CDPManager
82			* @dev Governance can also expand the list of approved minters to enable other systems to mint tokens
83			* @param _account The address to receive the newly minted tokens
84			* @param _amount The amount of tokens to mint
85			*/
86			function mint(address _account, uint256 _amount) external override {
87	√		_requireCallerIsBOorCdpMOrAuth();
88	√		_mint(_account, _amount);
89			}
90
91			/**
92			* @notice Burn existing tokens
93			* @dev Internal system function - only callable by BorrowerOperations or CDPManager
94			* @dev Governance can also expand the list of approved burners to enable other systems to burn tokens
95			* @param _account The address to burn tokens from
96			* @param _amount The amount of tokens to burn
97			*/
98			function burn(address _account, uint256 _amount) external override {
99	√	⟳	_requireCallerIsBOorCdpMOrAuth();
100	√	⟳	_burn(_account, _amount);
101			}
102
103			/**
104			* @notice Burn existing tokens from caller
105			* @dev Internal system function - only callable by BorrowerOperations or CDPManager
106			* @dev Governance can also expand the list of approved burners to enable other systems to burn tokens
107			* @param _amount The amount of tokens to burn
108			*/
109			function burn(uint256 _amount) external {
110			_requireCallerIsBOorCdpMOrAuth();
111			_burn(msg.sender, _amount);
112			}
113
114			// --- External functions ---
115
116	√	⟳	function totalSupply() external view override returns (uint256) {
117	√	⟳	return _totalSupply;
118			}
119
120	√	⟳	function balanceOf(address account) external view override returns (uint256) {
121	√	⟳	return _balances[account];
122			}
123
124			function transfer(address recipient, uint256 amount) external override returns (bool) {
125			_requireValidRecipient(recipient);
126			_transfer(msg.sender, recipient, amount);
127			return true;
128			}
129
130			function allowance(address owner, address spender) external view override returns (uint256) {
131			return _allowances[owner][spender];
132			}
133
134	√		function approve(address spender, uint256 amount) external override returns (bool) {
135	√		_approve(msg.sender, spender, amount);
136	√		return true;
137			}
138
139			function transferFrom(
140			address sender,
141			address recipient,
142			uint256 amount
143			) external override returns (bool) {
144			_requireValidRecipient(recipient);
145			_transfer(sender, recipient, amount);
146
147			uint256 cachedAllowance = _allowances[sender][msg.sender];
148			if (cachedAllowance != type(uint256).max) {
149			require(cachedAllowance >= amount, "ERC20: transfer amount exceeds allowance");
150			unchecked {
151			_approve(sender, msg.sender, cachedAllowance - amount);
152			}
153			}
154			return true;
155			}
156
157			function increaseAllowance(
158			address spender,
159			uint256 addedValue
160			) external override returns (bool) {
161			_approve(msg.sender, spender, _allowances[msg.sender][spender] + addedValue);
162			return true;
163			}
164
165			function decreaseAllowance(
166			address spender,
167			uint256 subtractedValue
168			) external override returns (bool) {
169			uint256 cachedAllowances = _allowances[msg.sender][spender];
170			require(cachedAllowances >= subtractedValue, "ERC20: decreased allowance below zero");
171			unchecked {
172			_approve(msg.sender, spender, cachedAllowances - subtractedValue);
173			}
174			return true;
175			}
176
177			// --- EIP 2612 Functionality (https://eips.ethereum.org/EIPS/eip-2612) ---
178
179			function DOMAIN_SEPARATOR() external view returns (bytes32) {
180			return domainSeparator();
181			}
182
183			function domainSeparator() public view override returns (bytes32) {
184			if (_chainID() == _CACHED_CHAIN_ID) {
185			return _CACHED_DOMAIN_SEPARATOR;
186			} else {
187			return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
188			}
189			}
190
191			function permit(
192			address owner,
193			address spender,
194			uint256 amount,
195			uint256 deadline,
196			uint8 v,
197			bytes32 r,
198			bytes32 s
199			) external override {
200			require(deadline >= block.timestamp, "EBTC: expired deadline");
201			bytes32 digest = keccak256(
202			abi.encodePacked(
203			"\x19\x01",
204			domainSeparator(),
205			keccak256(
206			abi.encode(_PERMIT_TYPEHASH, owner, spender, amount, _nonces[owner]++, deadline)
207			)
208			)
209			);
210			address recoveredAddress = ecrecover(digest, v, r, s);
211			require(recoveredAddress == owner, "EBTC: invalid signature");
212			_approve(owner, spender, amount);
213			}
214
215			/// @dev Return current nonce for msg.sender fOR EIP-2612 compatibility
216			function nonces(address owner) external view override(IERC2612, PermitNonce) returns (uint256) {
217			return _nonces[owner];
218			}
219
220			// --- Internal operations ---
221
222	√		function _chainID() private view returns (uint256) {
223	√		return block.chainid;
224			}
225
226			function _buildDomainSeparator(
227			bytes32 typeHash,
228			bytes32 name,
229			bytes32 version
230	√		) private view returns (bytes32) {
231	√		return keccak256(abi.encode(typeHash, name, version, _chainID(), address(this)));
232			}
233
234			// --- Internal operations ---
235			// Warning: sanity checks (for sender and recipient) should have been done before calling these internal functions
236
237			function _transfer(address sender, address recipient, uint256 amount) internal {
238			require(sender != address(0), "EBTCToken: zero sender!");
239			require(recipient != address(0), "EBTCToken: zero recipient!");
240
241			uint256 cachedSenderBalances = _balances[sender];
242			require(cachedSenderBalances >= amount, "ERC20: transfer amount exceeds balance");
243
244			unchecked {
245			// Safe because of the check above
246			_balances[sender] = cachedSenderBalances - amount;
247			}
248
249			_balances[recipient] = _balances[recipient] + amount;
250			emit Transfer(sender, recipient, amount);
251			}
252
253			function _mint(address account, uint256 amount) internal {
254	√		require(account != address(0), "EBTCToken: mint to zero recipient!");
255
256	√		_totalSupply = _totalSupply + amount;
257	√		_balances[account] = _balances[account] + amount;
258	√		emit Transfer(address(0), account, amount);
259			}
260
261			function _burn(address account, uint256 amount) internal {
262	√	⟳	require(account != address(0), "EBTCToken: burn from zero account!");
263
264	√	⟳	uint256 cachedBalance = _balances[account];
265	√	⟳	require(cachedBalance >= amount, "ERC20: burn amount exceeds balance");
266
267			unchecked {
268			// Safe because of the check above
269	√	⟳	_balances[account] = cachedBalance - amount;
270			}
271
272	√	⟳	_totalSupply = _totalSupply - amount;
273	√	⟳	emit Transfer(account, address(0), amount);
274			}
275
276			function _approve(address owner, address spender, uint256 amount) internal {
277	√		require(owner != address(0), "EBTCToken: zero approve owner!");
278	√		require(spender != address(0), "EBTCToken: zero approve spender!");
279
280	√		_allowances[owner][spender] = amount;
281	√		emit Approval(owner, spender, amount);
282			}
283
284			// --- 'require' functions ---
285
286			function _requireValidRecipient(address _recipient) internal view {
287			require(
288			_recipient != address(0) && _recipient != address(this),
289			"EBTC: Cannot transfer tokens directly to the EBTC token contract or the zero address"
290			);
291			require(
292			_recipient != cdpManagerAddress && _recipient != borrowerOperationsAddress,
293			"EBTC: Cannot transfer tokens directly to the CdpManager or BorrowerOps"
294			);
295			}
296
297			function _requireCallerIsBorrowerOperations() internal view {
298			require(
299			msg.sender == borrowerOperationsAddress,
300			"EBTCToken: Caller is not BorrowerOperations"
301			);
302			}
303
304			/// @dev authority check last to short-circuit in the case of use by usual immutable addresses
305			function _requireCallerIsBOorCdpMOrAuth() internal view {
306			require(
307	√	⟳	msg.sender == borrowerOperationsAddress \|\|
308	√	⟳	msg.sender == cdpManagerAddress \|\|
309			isAuthorized(msg.sender, msg.sig),
310			"EBTC: Caller is neither BorrowerOperations nor CdpManager nor authorized"
311			);
312			}
313
314			function _requireCallerIsCdpM() internal view {
315			require(msg.sender == cdpManagerAddress, "EBTC: Caller is not CdpManager");
316			}
317
318			// --- Optional functions ---
319
320			function name() external pure override returns (string memory) {
321			return _NAME;
322			}
323
324			function symbol() external pure override returns (string memory) {
325			return _SYMBOL;
326			}
327
328			function decimals() external pure override returns (uint8) {
329			return _DECIMALS;
330			}
331
332			function version() external pure override returns (string memory) {
333			return _VERSION;
334			}
335
336			function permitTypeHash() external pure override returns (bytes32) {
337			return _PERMIT_TYPEHASH;
338			}
339			}
340

1		// SPDX-License-Identifier: AGPL-3.0-only
2		pragma solidity 0.8.17;
3
4		import {EnumerableSet} from "./Dependencies/EnumerableSet.sol";
5		import {Authority} from "./Dependencies/Auth.sol";
6		import {RolesAuthority} from "./Dependencies/RolesAuthority.sol";
7
8		/// @notice Role based Authority that supports up to 256 roles.
9		/// @notice We have taken the tradeoff of additional storage usage for easier readabiliy without using off-chain / indexing services.
10		/// @author BadgerDAO Expanded from Solmate RolesAuthority
11		/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/authorities/RolesAuthority.sol)
12		/// @author Modified from Dappsys (https://github.com/dapphub/ds-roles/blob/master/src/roles.sol)
13		contract Governor is RolesAuthority {
14		using EnumerableSet for EnumerableSet.Bytes32Set;
15		using EnumerableSet for EnumerableSet.AddressSet;
16
17	√	bytes32 NO_ROLES = bytes32(0);
18
19		struct Role {
20		uint8 roleId;
21		string roleName;
22		}
23
24		struct Capability {
25		address target;
26		bytes4 functionSig;
27		uint8[] roles;
28		}
29
30		/*//////////////////////////////////////////////////////////////
31		STORAGE
32		//////////////////////////////////////////////////////////////*/
33
34		mapping(uint8 => string) internal roleNames;
35
36		/*//////////////////////////////////////////////////////////////
37		EVENTS
38		//////////////////////////////////////////////////////////////*/
39
40		event RoleNameSet(uint8 indexed role, string indexed name);
41
42		/*//////////////////////////////////////////////////////////////
43		CONSTRUCTOR
44		//////////////////////////////////////////////////////////////*/
45
46		/// @notice The contract constructor initializes RolesAuthority with the given owner.
47		/// @param _owner The address of the owner, who gains all permissions by default.
48	√	constructor(address _owner) RolesAuthority(_owner, Authority(address(this))) {}
49
50		/*//////////////////////////////////////////////////////////////
51		GETTERS
52		//////////////////////////////////////////////////////////////*/
53
54		/// @notice Returns a list of users that are assigned a specific role.
55		/// @dev This function searches all users and checks if they are assigned the given role.
56		/// @dev Intended for off-chain utility only due to inefficiency.
57		/// @param role The role ID to find users for.
58		/// @return usersWithRole An array of addresses that are assigned the given role.
59
60		function getUsersByRole(uint8 role) external view returns (address[] memory usersWithRole) {
61		// Search over all users: O(n) * 2
62		uint256 count;
63		for (uint256 i = 0; i < users.length(); i++) {
64		address user = users.at(i);
65		bool _canCall = doesUserHaveRole(user, role);
66		if (_canCall) {
67		count += 1;
68		}
69		}
70		if (count > 0) {
71		uint256 j = 0;
72		usersWithRole = new address[](count);
73		address[] memory _usrs = users.values();
74		for (uint256 i = 0; i < _usrs.length; i++) {
75		address user = _usrs[i];
76		bool _canCall = doesUserHaveRole(user, role);
77		if (_canCall) {
78		usersWithRole[j] = user;
79		j++;
80		}
81		}
82		}
83		}
84
85		/// @notice Returns a list of roles that an address has.
86		/// @dev This function searches all roles and checks if they are assigned to the given user.
87		/// @dev Intended for off-chain utility only due to inefficiency.
88		/// @param user The address of the user.
89		/// @return rolesForUser An array of role IDs that the user has.
90
91		function getRolesForUser(address user) external view returns (uint8[] memory rolesForUser) {
92		// Enumerate over all possible roles and check if enabled
93		uint256 count;
94		for (uint8 i = 0; i < type(uint8).max; i++) {
95		if (doesUserHaveRole(user, i)) {
96		count += 1;
97		}
98		}
99		if (count > 0) {
100		uint256 j = 0;
101		rolesForUser = new uint8[](count);
102		for (uint8 i = 0; i < type(uint8).max; i++) {
103		if (doesUserHaveRole(user, i)) {
104		rolesForUser[j] = i;
105		j++;
106		}
107		}
108		}
109		}
110
111		function getRolesFromByteMap(bytes32 byteMap) public pure returns (uint8[] memory roleIds) {
112		uint256 count;
113		for (uint8 i = 0; i < type(uint8).max; i++) {
114		bool roleEnabled = (uint256(byteMap >> i) & 1) != 0;
115		if (roleEnabled) {
116		count += 1;
117		}
118		}
119		if (count > 0) {
120		uint256 j = 0;
121		roleIds = new uint8[](count);
122		for (uint8 i = 0; i < type(uint8).max; i++) {
123		bool roleEnabled = (uint256(byteMap >> i) & 1) != 0;
124		if (roleEnabled) {
125		roleIds[j] = i;
126		j++;
127		}
128		}
129		}
130		}
131
132		// helper function to generate bytes32 cache data for given roleIds array
133		function getByteMapFromRoles(uint8[] memory roleIds) public pure returns (bytes32) {
134		bytes32 _data;
135		for (uint8 i = 0; i < roleIds.length; i++) {
136		_data \|= bytes32(1 << uint256(roleIds[i]));
137		}
138		return _data;
139		}
140
141		// helper function to return every authorization-enabled function signatures for given target address
142		function getEnabledFunctionsInTarget(
143		address _target
144		) public view returns (bytes4[] memory _funcs) {
145		bytes32[] memory _sigs = enabledFunctionSigsByTarget[_target].values();
146		if (_sigs.length > 0) {
147		_funcs = new bytes4[](_sigs.length);
148		for (uint256 i = 0; i < _sigs.length; ++i) {
149		_funcs[i] = bytes4(_sigs[i]);
150		}
151		}
152		}
153
154		/// @notice return all role IDs that have at least one capability enabled
155		function getActiveRoles() external view returns (Role[] memory activeRoles) {
156		revert("Planned off-chain QOL function, not yet implemented, please ignore for audit");
157		}
158
159		// If a role exists, flip enabled
160
161		// Return all roles that are enabled anywhere
162
163		function getCapabilitiesForTarget(
164		address target
165		) external view returns (Capability[] memory capabilities) {
166		revert("Planned off-chain QOL function, not yet implemented, please ignore for audit");
167		}
168
169		function getCapabilitiesByRole(
170		uint8 role
171		) external view returns (Capability[] memory capabilities) {
172		revert("Planned off-chain QOL function, not yet implemented, please ignore for audit");
173		}
174
175		function getRoleName(uint8 role) external view returns (string memory roleName) {
176		return roleNames[role];
177		}
178
179		/*//////////////////////////////////////////////////////////////
180		AUTHORIZED SETTERS
181		//////////////////////////////////////////////////////////////*/
182
183		function setRoleName(uint8 role, string memory roleName) external requiresAuth {
184		// TODO: require maximum size for a name
185	√	roleNames[role] = roleName;
186
187	√	emit RoleNameSet(role, roleName);
188		}
189		}
190

1			// SPDX-License-Identifier: MIT
2
3			pragma solidity 0.8.17;
4
5			import "./IPool.sol";
6
7			interface IActivePool is IPool {
8			// --- Events ---
9			event ActivePoolEBTCDebtUpdated(uint256 _EBTCDebt);
10			event SystemCollSharesUpdated(uint256 _coll);
11			event FeeRecipientAddressChanged(address _feeRecipientAddress);
12			event FeeRecipientClaimableCollSharesIncreased(uint256 _coll, uint256 _fee);
13			event FeeRecipientClaimableCollSharesDecreased(uint256 _coll, uint256 _fee);
14			event FlashLoanSuccess(address _receiver, address _token, uint256 _amount, uint256 _fee);
15			event SweepTokenSuccess(address indexed _token, uint256 _amount, address indexed _recipient);
16
17			// --- Functions ---
18			function transferSystemCollShares(address _account, uint256 _amount) external;
19
20			function increaseSystemCollShares(uint256 _value) external;
21
22			function transferSystemCollSharesAndLiquidatorReward(
23			address _account,
24			uint256 _shares,
25			uint256 _liquidatorRewardShares
26			) external;
27
28			function allocateSystemCollSharesToFeeRecipient(uint256 _shares) external;
29
30			function claimFeeRecipientCollShares(uint256 _shares) external;
31
32			function feeRecipientAddress() external view returns (address);
33
34			function getFeeRecipientClaimableCollShares() external view returns (uint256);
35
36			function setFeeRecipientAddress(address _feeRecipientAddress) external;
37			}
38

1			// SPDX-License-Identifier: MIT
2
3			pragma solidity 0.8.17;
4			import "./IPositionManagers.sol";
5
6			// Common interface for the Cdp Manager.
7			interface IBorrowerOperations is IPositionManagers {
8			// --- Events ---
9
10			event FeeRecipientAddressChanged(address _feeRecipientAddress);
11			event FlashLoanSuccess(address _receiver, address _token, uint256 _amount, uint256 _fee);
12
13			// --- Functions ---
14
15			function openCdp(
16			uint256 _EBTCAmount,
17			bytes32 _upperHint,
18			bytes32 _lowerHint,
19			uint256 _stEthBalance
20			) external returns (bytes32);
21
22			function openCdpFor(
23			uint _EBTCAmount,
24			bytes32 _upperHint,
25			bytes32 _lowerHint,
26			uint _collAmount,
27			address _borrower
28			) external returns (bytes32);
29
30			function addColl(
31			bytes32 _cdpId,
32			bytes32 _upperHint,
33			bytes32 _lowerHint,
34			uint256 _stEthBalanceIncrease
35			) external;
36
37			function withdrawColl(
38			bytes32 _cdpId,
39			uint256 _stEthBalanceDecrease,
40			bytes32 _upperHint,
41			bytes32 _lowerHint
42			) external;
43
44			function withdrawEBTC(
45			bytes32 _cdpId,
46			uint256 _amount,
47			bytes32 _upperHint,
48			bytes32 _lowerHint
49			) external;
50
51			function repayEBTC(
52			bytes32 _cdpId,
53			uint256 _amount,
54			bytes32 _upperHint,
55			bytes32 _lowerHint
56			) external;
57
58			function closeCdp(bytes32 _cdpId) external;
59
60			function adjustCdp(
61			bytes32 _cdpId,
62			uint256 _stEthBalanceDecrease,
63			uint256 _debtChange,
64			bool isDebtIncrease,
65			bytes32 _upperHint,
66			bytes32 _lowerHint
67			) external;
68
69			function adjustCdpWithColl(
70			bytes32 _cdpId,
71			uint256 _stEthBalanceDecrease,
72			uint256 _debtChange,
73			bool isDebtIncrease,
74			bytes32 _upperHint,
75			bytes32 _lowerHint,
76			uint256 _stEthBalanceIncrease
77			) external;
78
79			function claimSurplusCollShares() external;
80
81			function feeRecipientAddress() external view returns (address);
82			}
83

1			// SPDX-License-Identifier: MIT
2
3			pragma solidity 0.8.17;
4
5			import "./ILiquityBase.sol";
6			import "./ICdpManagerData.sol";
7
8			// Common interface for the Cdp Manager.
9			interface ICdpManager is ILiquityBase, ICdpManagerData {
10			// --- Functions ---
11			function getActiveCdpsCount() external view returns (uint256);
12
13			function getIdFromCdpIdsArray(uint256 _index) external view returns (bytes32);
14
15			function liquidate(bytes32 _cdpId) external;
16
17			function partiallyLiquidate(
18			bytes32 _cdpId,
19			uint256 _partialAmount,
20			bytes32 _upperPartialHint,
21			bytes32 _lowerPartialHint
22			) external;
23
24			function batchLiquidateCdps(bytes32[] calldata _cdpArray) external;
25
26			function redeemCollateral(
27			uint256 _EBTCAmount,
28			bytes32 _firstRedemptionHint,
29			bytes32 _upperPartialRedemptionHint,
30			bytes32 _lowerPartialRedemptionHint,
31			uint256 _partialRedemptionHintNICR,
32			uint256 _maxIterations,
33			uint256 _maxFee
34			) external;
35
36			function updateStakeAndTotalStakes(bytes32 _cdpId) external returns (uint256);
37
38			function syncAccounting(bytes32 _cdpId) external;
39
40			function getTotalStakeForFeeTaken(uint256 _feeTaken) external view returns (uint256, uint256);
41
42			function closeCdp(bytes32 _cdpId, address _borrower, uint256 _debt, uint256 _coll) external;
43
44			function removeStake(bytes32 _cdpId) external;
45
46			function getRedemptionRate() external view returns (uint256);
47
48			function getRedemptionRateWithDecay() external view returns (uint256);
49
50			function getRedemptionFeeWithDecay(uint256 _ETHDrawn) external view returns (uint256);
51
52			function decayBaseRateFromBorrowing() external;
53
54			function getCdpStatus(bytes32 _cdpId) external view returns (uint256);
55
56			function getCdpStake(bytes32 _cdpId) external view returns (uint256);
57
58			function getCdpDebt(bytes32 _cdpId) external view returns (uint256);
59
60			function getCdpCollShares(bytes32 _cdpId) external view returns (uint256);
61
62			function getCdpLiquidatorRewardShares(bytes32 _cdpId) external view returns (uint);
63
64			function initializeCdp(
65			bytes32 _cdpId,
66			uint256 _debt,
67			uint256 _coll,
68			uint256 _liquidatorRewardShares,
69			address _borrower
70			) external;
71
72			function updateCdp(
73			bytes32 _cdpId,
74			address _borrower,
75			uint256 _coll,
76			uint256 _debt,
77			uint256 _newColl,
78			uint256 _newDebt
79			) external;
80
81			function getTCR(uint256 _price) external view returns (uint256);
82
83			function checkRecoveryMode(uint256 _price) external view returns (bool);
84			}
85

1			// SPDX-License-Identifier: MIT
2
3			pragma solidity 0.8.17;
4
5			import "./ICollSurplusPool.sol";
6			import "./IEBTCToken.sol";
7			import "./ISortedCdps.sol";
8			import "./IActivePool.sol";
9			import "./IRecoveryModeGracePeriod.sol";
10			import "../Dependencies/ICollateralTokenOracle.sol";
11
12			// Common interface for the Cdp Manager.
13			interface ICdpManagerData is IRecoveryModeGracePeriod {
14			// --- Events ---
15
16			event FeeRecipientAddressChanged(address _feeRecipientAddress);
17			event StakingRewardSplitSet(uint256 _stakingRewardSplit);
18			event RedemptionFeeFloorSet(uint256 _redemptionFeeFloor);
19			event MinuteDecayFactorSet(uint256 _minuteDecayFactor);
20			event BetaSet(uint256 _beta);
21			event RedemptionsPaused(bool _paused);
22
23			event Liquidation(uint256 _liquidatedDebt, uint256 _liquidatedColl, uint256 _liqReward);
24			event Redemption(
25			uint256 _attemptedEBTCAmount,
26			uint256 _actualEBTCAmount,
27			uint256 _ETHSent,
28			uint256 _ETHFee,
29			address _redeemer
30			);
31			event CdpUpdated(
32			bytes32 indexed _cdpId,
33			address indexed _borrower,
34			uint256 _oldDebt,
35			uint256 _oldColl,
36			uint256 _debt,
37			uint256 _coll,
38			uint256 _stake,
39			CdpOperation _operation
40			);
41			event CdpLiquidated(
42			bytes32 indexed _cdpId,
43			address indexed _borrower,
44			uint _debt,
45			uint _coll,
46			CdpOperation _operation,
47			address _liquidator,
48			uint _premiumToLiquidator
49			);
50			event CdpPartiallyLiquidated(
51			bytes32 indexed _cdpId,
52			address indexed _borrower,
53			uint256 _debt,
54			uint256 _coll,
55			CdpOperation operation,
56			address _liquidator,
57			uint _premiumToLiquidator
58			);
59			event BaseRateUpdated(uint256 _baseRate);
60			event LastRedemptionTimestampUpdated(uint256 _lastFeeOpTime);
61			event TotalStakesUpdated(uint256 _newTotalStakes);
62			event SystemSnapshotsUpdated(uint256 _totalStakesSnapshot, uint256 _totalCollateralSnapshot);
63			event SystemDebtRedistributionIndexUpdated(uint256 _systemDebtRedistributionIndex);
64			event CdpDebtRedistributionIndexUpdated(bytes32 _cdpId, uint256 _debtRedistributionIndex);
65			event CdpArrayIndexUpdated(bytes32 _cdpId, uint256 _newIndex);
66			event StEthIndexUpdated(uint256 _oldIndex, uint256 _newIndex, uint256 _updTimestamp);
67			event CollateralFeePerUnitUpdated(uint256 _oldPerUnit, uint256 _newPerUnit, uint256 _feeTaken);
68			event CdpFeeSplitApplied(
69			bytes32 _cdpId,
70			uint256 _oldPerUnitCdp,
71			uint256 _newPerUnitCdp,
72			uint256 _collReduced,
73			uint256 collLeft
74			);
75
76			enum CdpOperation {
77			openCdp,
78			closeCdp,
79			adjustCdp,
80			syncAccounting,
81			liquidateInNormalMode,
82			liquidateInRecoveryMode,
83			redeemCollateral,
84			partiallyLiquidate
85			}
86
87			enum Status {
88			nonExistent,
89			active,
90			closedByOwner,
91			closedByLiquidation,
92			closedByRedemption
93			}
94
95			// Store the necessary data for a cdp
96			struct Cdp {
97			uint256 debt;
98			uint256 coll;
99			uint256 stake;
100			uint256 liquidatorRewardShares;
101			Status status;
102			uint128 arrayIndex;
103			}
104
105			/*
106			* --- Variable container structs for liquidations ---
107			*
108			* These structs are used to hold, return and assign variables inside the liquidation functions,
109			* in order to avoid the error: "CompilerError: Stack too deep".
110			**/
111
112			struct CdpDebtAndCollShares {
113			uint256 entireDebt;
114			uint256 entireColl;
115			uint256 pendingDebtReward;
116			}
117
118			struct LiquidationLocals {
119			bytes32 cdpId;
120			uint256 partialAmount; // used only for partial liquidation, default 0 means full liquidation
121			uint256 price;
122			uint256 ICR;
123			bytes32 upperPartialHint;
124			bytes32 lowerPartialHint;
125			bool recoveryModeAtStart;
126			uint256 TCR;
127			uint256 totalColSurplus;
128			uint256 totalColToSend;
129			uint256 totalDebtToBurn;
130			uint256 totalDebtToRedistribute;
131			uint256 totalColReward;
132			bool sequenceLiq;
133			}
134
135			struct LiquidationRecoveryModeLocals {
136			uint256 entireSystemDebt;
137			uint256 entireSystemColl;
138			uint256 totalDebtToBurn;
139			uint256 totalColToSend;
140			uint256 totalColSurplus;
141			bytes32 cdpId;
142			uint256 price;
143			uint256 ICR;
144			uint256 totalDebtToRedistribute;
145			uint256 totalColReward;
146			bool sequenceLiq;
147			}
148
149			struct LocalVariables_OuterLiquidationFunction {
150			uint256 price;
151			bool recoveryModeAtStart;
152			uint256 liquidatedDebt;
153			uint256 liquidatedColl;
154			}
155
156			struct LocalVariables_LiquidationSequence {
157			uint256 i;
158			uint256 ICR;
159			bytes32 cdpId;
160			bool backToNormalMode;
161			uint256 entireSystemDebt;
162			uint256 entireSystemColl;
163			uint256 price;
164			uint256 TCR;
165			}
166
167			struct SingleRedemptionInputs {
168			bytes32 cdpId;
169			uint256 maxEBTCamount;
170			uint256 price;
171			bytes32 upperPartialRedemptionHint;
172			bytes32 lowerPartialRedemptionHint;
173			uint256 partialRedemptionHintNICR;
174			}
175
176			struct LiquidationValues {
177			uint256 entireCdpDebt;
178			uint256 debtToOffset;
179			uint256 totalCollToSendToLiquidator;
180			uint256 debtToRedistribute;
181			uint256 collSurplus;
182			uint256 collReward;
183			}
184
185			struct LiquidationTotals {
186			uint256 totalDebtInSequence;
187			uint256 totalDebtToOffset;
188			uint256 totalCollToSendToLiquidator;
189			uint256 totalDebtToRedistribute;
190			uint256 totalCollSurplus;
191			uint256 totalCollReward;
192			}
193
194			// --- Variable container structs for redemptions ---
195
196			struct RedemptionTotals {
197			uint256 remainingEBTC;
198			uint256 totalEBTCToRedeem;
199			uint256 totalETHDrawn;
200			uint256 totalCollSharesSurplus;
201			uint256 ETHFee;
202			uint256 ETHToSendToRedeemer;
203			uint256 decayedBaseRate;
204			uint256 price;
205			uint256 totalEBTCSupplyAtStart;
206			uint256 totalCollSharesAtStart;
207			uint256 tcrAtStart;
208			}
209
210			struct SingleRedemptionValues {
211			uint256 eBtcToRedeem;
212			uint256 stEthToRecieve;
213			uint256 collSurplus;
214			uint256 liquidatorRewardShares;
215			bool cancelledPartial;
216			bool fullRedemption;
217			}
218
219			function totalStakes() external view returns (uint256);
220
221			function ebtcToken() external view returns (IEBTCToken);
222
223			function systemStEthFeePerUnitIndex() external view returns (uint256);
224
225			function systemStEthFeePerUnitIndexError() external view returns (uint256);
226
227			function stEthIndex() external view returns (uint256);
228
229			function calcFeeUponStakingReward(
230			uint256 _newIndex,
231			uint256 _prevIndex
232			) external view returns (uint256, uint256, uint256);
233
234			function syncGlobalAccounting() external; // Accrues StEthFeeSplit without influencing Grace Period
235
236			function syncGlobalAccountingAndGracePeriod() external; // Accrues StEthFeeSplit and influences Grace Period
237
238			function getAccumulatedFeeSplitApplied(
239			bytes32 _cdpId,
240			uint256 _systemStEthFeePerUnitIndex
241			) external view returns (uint256, uint256);
242
243			function getNominalICR(bytes32 _cdpId) external view returns (uint256);
244
245			function getICR(bytes32 _cdpId, uint256 _price) external view returns (uint256);
246
247			function getSyncedCdpDebt(bytes32 _cdpId) external view returns (uint256);
248
249			function getSyncedCdpCollShares(bytes32 _cdpId) external view returns (uint256);
250
251			function getSyncedICR(bytes32 _cdpId, uint256 _price) external view returns (uint256);
252
253			function getSyncedTCR(uint256 _price) external view returns (uint256);
254
255			function getPendingRedistributedDebt(bytes32 _cdpId) external view returns (uint256);
256
257			function hasPendingRedistributedDebt(bytes32 _cdpId) external view returns (bool);
258
259			function getDebtAndCollShares(
260			bytes32 _cdpId
261			) external view returns (uint256 debt, uint256 coll, uint256 pendingEBTCDebtReward);
262
263			function canLiquidateRecoveryMode(uint256 icr, uint256 tcr) external view returns (bool);
264			}
265

1			// SPDX-License-Identifier: MIT
2
3			pragma solidity 0.8.17;
4
5			interface ICollSurplusPool {
6			// --- Events ---
7
8			event SurplusCollSharesUpdated(address indexed _account, uint256 _newBalance);
9			event CollSharesTransferred(address _to, uint256 _amount);
10
11			event SweepTokenSuccess(address indexed _token, uint256 _amount, address indexed _recipient);
12
13			// --- Contract setters ---
14
15			function getTotalSurplusCollShares() external view returns (uint256);
16
17			function getSurplusCollShares(address _account) external view returns (uint256);
18
19			function increaseSurplusCollShares(address _account, uint256 _amount) external;
20
21			function claimSurplusCollShares(address _account) external;
22
23			function increaseTotalSurplusCollShares(uint256 _value) external;
24			}
25

1			// SPDX-License-Identifier: MIT
2
3			pragma solidity 0.8.17;
4
5			import "../Dependencies/IERC20.sol";
6			import "../Dependencies/IERC2612.sol";
7
8			interface IEBTCToken is IERC20, IERC2612 {
9			// --- Events ---
10			event EBTCTokenBalanceUpdated(address _user, uint _amount);
11
12			// --- Functions ---
13
14			function mint(address _account, uint256 _amount) external;
15
16			function burn(address _account, uint256 _amount) external;
17			}
18

1			// SPDX-License-Identifier: MIT
2
3			pragma solidity 0.8.17;
4
5			interface IERC3156FlashBorrower {
6			/**
7			* @dev Receive a flash loan.
8			* @param initiator The initiator of the loan.
9			* @param token The loan currency.
10			* @param amount The amount of tokens lent.
11			* @param fee The additional amount of tokens to repay.
12			* @param data Arbitrary data structure, intended to contain user-defined parameters.
13			* @return The keccak256 hash of "ERC3156FlashBorrower.onFlashLoan"
14			*/
15			function onFlashLoan(
16			address initiator,
17			address token,
18			uint256 amount,
19			uint256 fee,
20			bytes calldata data
21			) external returns (bytes32);
22			}
23